Tin nhắn Arecibo là một tin nhắn vô tuyến liên sao năm 1974 mang thông tin cơ bản về loài người và Trái đất được gửi đến cụm sao hình cầu M13 với hy vọng trí thông minh ngoài trái đất có thể nhận và giải mã nó ... Tin nhắn bao gồm 1.79 chữ số nhị phân, khoảng 210 byte ...

Số 1.679 đã được chọn vì nó là một nửa số (tích của hai số nguyên tố), được sắp xếp theo hình chữ nhật là 73 hàng bằng 23 cột. Sắp xếp thay thế, 23 hàng theo 73 cột, tạo ra một bộ ký tự không thể hiểu được (cũng như tất cả các định dạng X / Y khác).

Đây là thông điệp với màu sắc được thêm vào để làm nổi bật các phần riêng biệt của nó. Việc truyền nhị phân thực tế không mang thông tin màu.

Nguồn: Wikipedia

Nhiệm vụ của bạn là xuất Thông báo Arecibo theo cách sắp xếp chính xác 23x73 được hiển thị trong hình ảnh. Bất kỳ định dạng đầu ra nào cũng được chấp nhận:

• Văn bản, sử dụng một ký tự cho các ký tự và một ký tự khác cho số không (sử dụng các quy tắc thông thường để phân tách hàng)
• Mảng 2D gồm hai giá trị riêng biệt
• Một hình ảnh 23x73 với hai màu sắc khác biệt
• Luồng Aan không bị gián đoạn gồm 1679 mục có hai giá trị riêng biệt (nghĩa là bất kỳ định dạng nào ở trên, nhưng bằng phẳng.)
• Một số nguyên 1679 bit. Chỉ ra thứ tự bit và byte (endianness) trong giải pháp của bạn.

Để thuận tiện cho bạn, đây là phiên bản có thể sao chép (cũng là một ví dụ đầu ra ở định dạng văn bản):

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

Nếu ngôn ngữ của bạn, vì một số lý do, có tích hợp sẵn cho Thông báo Arecibo, bạn không được sử dụng nội dung đó.

Chúc may mắn!

CẬP NHẬT: Tôi đã chấp nhận câu trả lời 05AB1E vì đây là câu trả lời đầu tiên ngắn hơn tin nhắn gốc. Đừng để điều đó ngăn cản bạn từ các giải pháp mới.

CẬP NHẬT 2019-09-09: Câu trả lời được chấp nhận đã chuyển sang câu trả lời mới 05AB1E, vì nó làm lỗi thời câu trả lời 05AB1E trước đó. Điểm giống như đi cập nhật trước đó; giải pháp mới vẫn được chào đón.

05AB1E , 182 byte

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

Hãy thử trực tuyến! (sử dụng 1cho 0 và 0cho 1, như được cho phép bởi câu hỏi).

Hãy thử trực tuyến! (5 byte dài hơn, 0cho 0 và 1cho 1, đã thêm các dòng mới để dễ đọc).

Hầu hết mã là hằng số nguyên N-255, phần còn lại là bộ giải mã Hệ thống số không đối xứng , sử dụng xác suất mã hóa cứng là 75% / 25% (tần số thực tế là 0 là 76,35%, gần đến 75% sẽ chỉ tiết kiệm 1,2 bit trong tải trọng, trong khi 75% đẹp và tròn cho phép chúng tôi lưu một vài byte trong bộ giải mã).

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

Đây là bộ mã hóa ANS tạo ra hằng số: Hãy thử trực tuyến!

Î                          # 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 byte

Đã lưu 15 byte nhờ 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×:

Hãy thử trực tuyến! hoặc với định dạng bổ sung

Chuỗi ba mã hóa cơ sở-255 với sự xuất hiện của 0000thay thế bởi 2.

Java, 688 678 590 379 361 byte

Trả về một chuỗi.

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

-10 byte bằng cách trả về luồng thô (câu trả lời cũ)
-88 byte bằng cách sử dụng 10 số cơ bản (cảm ơn @ceilingcat!) -211
byte (tôi biết rằng nó có thể được đánh gôn!) Bằng cách sử dụng BigInteger được mã hóa cơ sở 36 (cảm ơn @JollyJoker !)
-18 byte bằng cách sử dụng một số nguyên được mã hóa khác (cảm ơn lần nữa @JollyJoker)

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

Giải trình:

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

Thạch , 213 byte

“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ȯÑḢɼ’

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

Tôi đã chơi xung quanh với mã hóa Huffman, nhưng sự cải thiện về kích thước dữ liệu đã vượt trội hơn so với mã bổ sung. Như vậy, đây đơn giản là phiên bản được mã hóa cơ sở 250 của đầu ra mong muốn. Đầu ra bao gồm một số nguyên mà khi được giải mã là cơ sở 2 tính toán sẽ mang lại danh sách 1D gồm 1s và 2s. Cảm ơn @Emigna đã chỉ ra sự thay đổi trong các quy tắc.

Hãy thử trực tuyến - với giải mã hơn nữa để chứng minh đầu ra!

Nếu mã hóa nhị phân thông thường hơn được ưa thích, thì đây là mã hóa đại diện số nguyên của thông điệp nhị phân đảo ngược. Bit quan trọng nhất của số nguyên biểu thị phần đầu của tin nhắn.

Brainfuck, 2360 2008 1938 byte

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

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

Tôi có thể sẽ chơi golf này thậm chí sớm hơn nữa.

Deadfish ~ , 1115 1088 1084 byte

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

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

Nếu ai đó có đủ kiên nhẫn để chơi gôn hơn nữa, tôi chào bạn trước thời hạn. : P

-27 byte bằng cách in 10 và 100 ở những nơi áp dụng.
-4 byte bằng cách in ba 1000 và một 1001 trên dòng 3

Piet , 1763 codel

Xuất ra một luồng 0 và 1 (không ngắt dòng).

Codel cỡ 1:

Codel size 4, để xem dễ dàng hơn:

Giải trình

• Đầu tiên, đẩy giá trị sentinel -1 lên ngăn xếp.
• Sau đó đẩy tin nhắn Arecibo, theo thứ tự ngược lại (vì đó là một ngăn xếp), sử dụng mã hóa độ dài chạy.
• Cuối cùng, xen kẽ giữa hai vòng lặp, một số không in và một số in khác.
  • Bộ đếm vòng lặp là giá trị ngăn xếp hiện tại, giảm dần cho đến khi nó về 0, tại đó nó bị loại bỏ và chúng ta chuyển sang vòng lặp khác.
  • Giữa vòng lặp số 0 và vòng lặp, kiểm tra giá trị sentinel, thoát nếu nó được tìm thấy.

Ghi chú

Chương trình đi theo một đường xoắn ốc, theo chiều kim đồng hồ từ trên cùng bên trái vào trung tâm. Các khối màu đen rải rác gần như theo các đường chéo là điều khiển luồng. Đây là dấu vết từ NPiet .

Tôi đã làm việc này kể từ ngày thử thách này tăng lên, nhưng phải mất một ít thời gian để đưa thông điệp "được viết" vào bức tranh! Tôi đã viết các vòng lặp cuối cùng và giá trị sentinel trước, và sau đó xây dựng thông điệp từ trung tâm ra bên ngoài. (Vì Piet luôn bắt đầu thực hiện từ trên cùng bên trái, tôi dự kiến ​​sẽ phải xáo trộn và xoay hình ảnh xung quanh để tránh khoảng trắng thừa, nhưng nó hoàn toàn phù hợp!)

Sự thật thú vị: Mã hóa độ dài chạy trong Piet không (tự nó) tiết kiệm bất kỳ không gian nào. Phải mất n codel một màu để đẩy giá trị n lên stack hoặc n codel có các màu khác nhau để đẩy nhiều 1 bit lên stack. Vì vậy, đó là cùng một số lượng codel. Nhưng những con số lớn hơn mà RLE mang lại cho bạn có nghĩa là bạn có thể sử dụng các thủ thuật số học (ví dụ thay vì đẩy 9, bạn có thể đẩy 3, nhân đôi và nhân) để giảm số lượng codel và các khối có hình dạng ngộ nghĩnh để điền vào khoảng trắng có sẵn.

Tôi không chắc chắn về cách tính điểm cho các mục của Piet. Tôi tìm thấy một số dường như đếm tất cả các codel, và một số khác rõ ràng chỉ đếm những người được sử dụng tích cực. Tôi chỉ đếm tất cả; bỏ qua các codel trắng (ngay cả những cái mà chương trình không bao giờ di chuyển qua) có vẻ giống như bỏ qua khoảng trắng trong một ngôn ngữ lập trình điển hình hơn.

Ồ, và tôi vừa mới (hai giờ sau khi đăng bài) nhận ra rằng tôi đã lãng phí chút thời gian cuối cùng để làm việc này. Tôi muốn cắt bỏ hàng và cột cuối cùng gần như trắng hoàn toàn, vì vậy tôi đã xáo trộn mọi thứ xung quanh ... bao gồm các khối kiểm soát dòng chảy màu đen. Nhưng các cạnh của hình ảnh hoạt động giống như màu đen! Nếu tôi chỉ nhớ điều đó, tôi sẽ không cần phải dành quá nhiều thời gian để đánh đố những rắc rối của DP và CC ...

C # (Trình biên dịch tương tác Visual C #) , 366 332 329 319 byte

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

Thay thế tất cả các trường hợp ␀với \0để kiểm tra.

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

C # (Trình biên dịch tương tác Visual C #) , 305 byte, 210 ký tự

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

Tương tự với ở trên, thay thế ␀bằng \0để kiểm tra. Đầu ra như IEnumerable<string>.

Dùng thử trực tuyến! (Được phép của Jo King)

Perl 6 , 368 byte

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

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

Chuỗi dài là thông điệp dưới dạng một số cơ sở 36 (với một tiền tố 1 bit duy nhất để duy trì các số 0 đứng đầu) sau đó được chuyển đổi trở lại thành nhị phân và in 23 bit mỗi lần.

Ngôn ngữ Wolfram (Mathicala) , 383 byte

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

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

Node.js , 333 byte

Trả về một chuỗi nhị phân gồm 1.79 ký tự.

_=>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

Hãy thử trực tuyến! (với đầu ra được định dạng)

JavaScript (ES8), 413 byte

Trả về một chuỗi nhị phân gồm 1.79 ký tự.

_=>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))

Hãy thử trực tuyến! (với đầu ra được định dạng)

Bong bóng, 275 236 byte

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

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

bash + công cụ GNU, 351 byte

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

TIO

MathGolf , 223 220 byte

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

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

Giải trình

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

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/

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

Python 2 , 336 byte

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

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

In một chuỗi byte

Java (OpenJDK 8) , 364 byte

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

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

Giải thích: Đầu tiên n->new java.math.BigInteger(str,36).toString(2), chỉ cần chuyển đổi một số cơ số 36 thành nhị phân, nhưng điều đó cần thêm chín ký tự cho các số 0 đứng đầu. Sau đó, tôi có ý tưởng mã hóa chiều dài chạy một số số 0 dưới dạng twos. Độ dài bốn số 0 dường như giảm thiểu chiều dài cơ số 36, vì vậyn->new java.math.BigInteger(str,36).toString(3).replaceAll("2","0000")

Xem phần thảo luận dưới câu trả lời này để biết cách sửa lỗi số 0 hàng đầu của @KevinCruijssen

[Python 2] , 345 byte

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

Tôi đã mã hóa độ dài của chuỗi 0 là một byte bắt đầu từ chr (31). Sau đó, tôi mã hóa 10101 còn lại dưới dạng số nhị phân bắt đầu từ chr (70) cho đến chr (126). Các chuỗi nhị phân không phù hợp được chia thành các phần nhỏ hơn.

Chỉnh sửa: Giảm xuống còn 326 byte. Cảm ơn vua Jo

Chỉnh sửa: Đã sửa lỗi trong chương trình tạo mã

Chỉnh sửa: Chỉnh sửa cuối cùng

Zsh , 577 byte

thử trực tuyến !!

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}

Được sử dụng logic mã hóa tùy chỉnh. Chuỗi Scó 421 ký tự, có thể có thể được nén thêm một chút. Chữ cái a-wđại diện cho 0s lặp đi lặp lại . Các số 1-9đại diện cho 1s lặp đi lặp lại . Chữ x y zđại diện 10 100 1000tương ứng.

Có lẽ tôi nên thử mã hóa cặp byte hoặc Ascii85 .

Bash , 702 697 byte

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

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

Ruby , 362 byte

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

Số nguyên được viết trong cơ sở 36. Chắc chắn có một cách hiệu quả hơn để nén số nguyên, ví dụ như với zlibhoặc base64.

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

[C ++ (VC ++) (nhưng cũng được thử nghiệm với gcc)], 585 byte

#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);}}}

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

Phiên bản không có bản quyền (thiếu phần ngắt sau phần tử thứ 1679 và đến bản thứ 1680):

#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;
}

như một giải thích: tôi đã nối 73 dòng đầu ra mẫu cho một dòng dài. tôi đã mã hóa chúng theo hệ thập lục phân trong đó thứ tự bit là msbfirst (sử dụng chương trình này https://github.com/Marc-Bender/longBinaryStreamToHex/release/doad/addedErrorCode-4/longBinaryStreamToHex.exe ) tôi đã rút ngắn Kết quả đó bằng 70 Các chữ số thập lục phân bằng cách sử dụng các chữ cái 'G' - 'Z' làm dấu hiệu để lặp lại Chữ số cuối cùng trong một số lần nhất định (Z = 2 lần, Y = 3 lần nữa), phần còn lại sẽ tương đối tự giải thích cho Người chơi gôn . lạm dụng bộ tiền xử lý để rút ngắn các vòng lặp, lạm dụng ,Toán tử và tương tự.

Định dạng đầu ra là luồng không bị gián đoạn 1679 0/1 giá trị.

Perl 6 , 348 byte

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

Dựa trên giải pháp Java của Benjamin Urquhart .

Sử dụng một luồng thẳng gồm 0 và 1 ký tự. Liên kết dưới đây có một số mã để làm đẹp đầu ra.

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

Tcl , 366 byte

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

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

C ++ (với thư viện đa độ chính xác Gnu), 359 byte

Điều này xuất ra chuỗi dưới dạng một dòng. Nó sử dụng '1' cho 0 và '0' cho 1: /

Nó chỉ đơn giản là đọc chuỗi nhúng là cơ sở 62 và in nó thành cơ sở 2.

Sử dụng g++ -g arecibo.cpp -lgmp -lgmpxxđể biên dịch và liên kết

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

Perl 6 , 276 byte

: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

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

Đầu ra là một chuỗi 1679 0 và 1. Bạn có thể có nó trên các dòng khác nhau bằng cách thêm .comb(23)>>trướcsay .

Giải trình:

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

Tôi có thể có thể lưu byte bằng cách sử dụng đầu ra dưới dạng số nguyên 1679 bit hoặc đảo ngược biểu diễn bit.

C ++ (gcc) , 748 byte

#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]);}}

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

Bằng cách thay thế chuỗi con được sử dụng nhiều nhất bằng một ký tự mới cho đến khi nó không còn giá trị nữa

Python 3 , 331 byte

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:])

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