Dựa trên câu hỏi Math.SE này ; số được sao chép từ câu trả lời này . Số ban đầu từ một video Numberphile , tất nhiên.

Nhiệm vụ của bạn là xuất ra số nguyên tố 1350 chữ số sau đây:

888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888111111111111111111111111888888111111111111111111111111888888111111811111111118111111888888111118811111111118811111888888111188811111111118881111888888111188811111111118881111888888111888811111111118888111888888111888881111111188888111888888111888888111111888888111888888111888888888888888888111888888111888888888888888888111888888111888888888888888888111888888811188888888888888881118888188811188888888888888881118881188881118888888888888811188881118888111888888888888111888811111888811118888888811118888111111188881111111111111188881111111118888111111111111888811111111111888811111111118888111111111111188881111111188881111111111111118888811118888811111111111111111888881188888111111111111111111118888888811111111111111111111111888888111111111111111111111111118811111111111111111111111111111111111111111111062100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

Bạn có thể tùy ý bao gồm các dòng mới trong đầu ra.

Quy tắc

• Đây là độ phức tạp kolmogorov , vì vậy không có đầu vào.
• Chương trình của bạn phải chấm dứt trong vòng một giờ trên một máy tính tiêu chuẩn - nếu nó gần, tôi sẽ sử dụng của tôi để thử nghiệm. Nếu chương trình của bạn chạy quá một phút hoặc không chấm dứt trên TIO, vui lòng bao gồm thời gian trên máy tính của bạn.
• Đây là mã golf , vì vậy mã ngắn nhất, tính bằng byte, sẽ thắng.

Thạch , 74 71 69 68 66 byte

“©ạ-3ṗÇñ"ỤḍV8żṢ?ḤsMVE[,Ṃƭ"ḞÇsẇʂ(ụFsẠʂẆŀṣ’ḃ19ĖŒṙị⁾81s30m0Z062 ȷ446‘

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

Làm thế nào nó hoạt động

Nghĩa đen “©ạ-3ṗÇñ"ỤḍV8żṢ?ḤsMVE[,Ṃƭ"ḞÇsẇʂ(ụFsẠʂẆŀṣ’thay thế tất cả các ký tự bằng các điểm mã của chúng trong trang mã của Jelly và diễn giải kết quả dưới dạng số cơ bản (250 tính từ), thu được số nguyên sau.

103877200905186099028820568168804302565394743652609510039112658230540917082292838565138059974

Sau đó, ḃ19chuyển đổi số này thành cơ sở sinh học 19, thu được mảng chữ số sau.

16,14,18,12,19,11,3,12,5,10,3,14,4,9,3,15,4,8,3,6,6,4,4,7,3,4,10,3,4,6,3,3,12,3,4,5,3,2,14,3,4,4,3,7,9,4,3,4,3,8,9,4,3,3,3,9,8,4,4,2,3,9,8,5,3,2,3,9,8,6,3,1

Bây giờ, ĖŒṙliệt kê các chữ số và thực hiện giải mã độ dài chạy, thu được mảng sau.

1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,6,6,7,7,7,8,8,8,8,8,8,8,8,8,8,8,8,9,9,9,9,9,10,10,10,10,10,10,10,10,10,10,11,11,11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,13,13,13,13,14,14,14,14,14,14,14,14,14,15,15,15,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,17,17,18,18,18,18,18,18,18,18,19,19,19,20,20,20,20,20,20,21,21,21,21,21,21,22,22,22,22,23,23,23,23,24,24,24,24,24,24,24,25,25,25,26,26,26,26,27,27,27,27,27,27,27,27,27,27,28,28,28,29,29,29,29,30,30,30,30,30,30,31,31,31,32,32,32,33,33,33,33,33,33,33,33,33,33,33,33,34,34,34,35,35,35,35,36,36,36,36,36,37,37,37,38,38,39,39,39,39,39,39,39,39,39,39,39,39,39,39,40,40,40,41,41,41,41,42,42,42,42,43,43,43,44,44,44,44,44,44,44,45,45,45,45,45,45,45,45,45,46,46,46,46,47,47,47,48,48,48,48,49,49,49,50,50,50,50,50,50,50,50,51,51,51,51,51,51,51,51,51,52,52,52,52,53,53,53,54,54,54,55,55,55,56,56,56,56,56,56,56,56,56,57,57,57,57,57,57,57,57,58,58,58,58,59,59,59,59,60,60,61,61,61,62,62,62,62,62,62,62,62,62,63,63,63,63,63,63,63,63,64,64,64,64,64,65,65,65,66,66,67,67,67,68,68,68,68,68,68,68,68,68,69,69,69,69,69,69,69,69,70,70,70,70,70,70,71,71,71,72

Sau đó, ị⁾81lập chỉ mục vào chuỗi 81 , thay thế các số lẻ bằng ký tự 8 , số chẵn bằng ký tự 1 . Sau đó, s30chia kết quả thành các đoạn có độ dài 30. Hiển thị một đoạn trên mỗi dòng, kết quả sẽ như sau.

888888888888888811111111111111
888888888888888888111111111111
888888888888888888811111111111
888111111111111888881111111111
888111111111111118888111111111
888111111111111111888811111111
888111111888888111188881111111
888111188888888881118888111111
888111888888888888111888811111
888118888888888888811188881111
888111111188888888811118881111
888111111118888888881111888111
888111111111888888881111888811
888111111111888888881111188811
888111111111888888881111118881

Bây giờ, m0nối các mảng của khối với một bản sao đảo ngược của chính nó. Sau đó, Znén kết quả, hoán chuyển các hàng và cột.

888888888888888888888888888888
888888888888888888888888888888
888888888888888888888888888888
888111111111111111111111111888
888111111111111111111111111888
888111111811111111118111111888
888111118811111111118811111888
888111188811111111118881111888
888111188811111111118881111888
888111888811111111118888111888
888111888881111111188888111888
888111888888111111888888111888
888111888888888888888888111888
888111888888888888888888111888
888111888888888888888888111888
888811188888888888888881118888
188811188888888888888881118881
188881118888888888888811188881
118888111888888888888111888811
111888811118888888811118888111
111188881111111111111188881111
111118888111111111111888811111
111111888811111111118888111111
111111188881111111188881111111
111111118888811118888811111111
111111111888881188888111111111
111111111118888888811111111111
111111111111888888111111111111
111111111111118811111111111111
111111111111111111111111111111

0là một nilad không thể chỉnh sửa, do đó, kết quả từ trước được in (không ngắt dòng) và giá trị trả về được đặt thành 0 .

62là một nilad không thể chỉnh sửa khác, vì vậy kết quả từ trước ( 0 ) được in và giá trị trả về được đặt thành 62 .

ȷ446là một nilad không thể khác 62 được in và giá trị trả về được đặt thành 10 ⁴⁴⁶ .

Cuối cùng, ‘tăng kết quả. Kết quả cuối cùng ( 10 ⁴⁴⁶ + 1 ) được in khi chương trình kết thúc.

SOGL V0.12 , 81 78 75 73 byte

$!╚Qαūπōθ(└↓Υ8Π⁶!√|ΠΚψ░⅜Υ‛⁷>∙↓ts3]δεΧ‰“8«─'½Κ81¹¹I⌡_¹◄ø∑'¹n╬³0621"η“⌡01⁰∑

Hãy thử nó ở đây!

Giải trình:

...“                 push a big number of the RLE lengths of the top part
    8«─              convert from base 10 to base 16 (15 was the max length, and making it base 15 wasn't worth it)
       '½Κ           prepend to the array 48
          81¹        push [8, 1]
             ¹       wrap those two in an array
              I      rotate clockwise, resulting in [[8, 48], [1, 2], [8, 9], [1, 12], ...]
               ⌡_¹   flatten (iterate over, splat current items contents on stack, collect the contents in an array)
                  ◄  run-length decode

ø∑                   join as a string
  '¹n                split into lines of length 15
     ╬³              palindromize horizontally with no overlap
       0621          push 0, 6, 2, and 1
           "η“       push 445
              ⌡      that many times do
               0       push 0
                1    push 1
                 ⁰∑  join the stack together in a string

Thạch , 136 byte

“ßṪṭAƭẠvµM⁾ṖOḥ⁻Ɠ×Ṣ~*pṭẒFỵṿ¦4ÇḟọLÑOcKɲ⁶2*Ḣɲ’b45;@€1ẋ/€ø“Œ\⁴rrNỊġ:,xƙŒ#ṠƲQçḷĠ%&⁻ɼiḂŀB<Ȧƈg(Ṇb>TḥḄ|ḃṘƬ#l7ƇØṃ’b94;@€8ẋ/€ðżF;0;6;2;1;0ẋ445¤;1Ḍ

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

Giải thích (số rút ngắn)

“ßṪṭ...*Ḣɲ’b45;@€1ẋ/€ø“Œ\⁴...ƇØṃ’b94;@€8ẋ/€ðżF;0;6;2;1;0ẋ445¤;1Ḍ  Main link
“ßṪṭ...*Ḣɲ’b45;@€1ẋ/€                                             Run-length encoded 1s
“ßṪṭ...*Ḣɲ’                                                      The base-45 encoding of the list of the run-lengths of 1s
           b45                                                    in base 45
                €                                                 For each element
              ;@                                                  prepend
                 1                                                1
                    €                                             For each sublist
                   /                                              Reduce over
                  ẋ                                               Repeat list (this gets a bunch of lists of 1s)
                     ø“Œ\⁴...ƇØṃ’b94;@€8ẋ/€                       Run-length encoded 8s
                      “Œ\⁴...ƇØṃ’                                 The base-94 encoding of the list of the run-lengths of 8s
                                 b94                              in base 94
                                      €                           For each element
                                    ;@                            prepend
                                       8                          8
                                          €                       For each sublist
                                         /                        Reduce over
                                        ẋ                         Repeat list (this gets a bunch of lists of 8s)
                                           ðżF;0;6;2;1;0ẋ445¤;1Ḍ  With both of the previous lists of lists, construct the final string
                                            ż                     Interleave them
                                             F                    Flatten it
                                              ;0                  Append 0
                                                ;6                Append 6
                                                  ;2              Append 2
                                                    ;1            Append 1
                                                      ;           Append
                                                       0ẋ445¤     (Nilad)
                                                       0          0
                                                        ẋ445      445 times
                                                             ;1   Append 1
                                                               Ḍ  Convert decimal digits to a number

-121 byte nhờ Dennis sử dụng “...’chữ thay vì số bình thường

Thạch ,  133 84  73 byte

“÷iþṃL7[ḲʂƘⱮ=ƬƤ¬`RẹŀẹY÷n£ị€ıø&ḟ"gPƲ_ÇḊṪ’b⁴48;ĖŒṙḂ×7‘s15m€0F;“¡©£¢‘Ḍ×ȷ446‘

Hãy thử trực tuyến! (chân trang định dạng số thập phân với kích thước mang lại huy hiệu).

Làm sao?

Một dạng được mã hóa theo chiều dài chạy ở định dạng nhị phân ở phía bên trái của huy hiệu 8và 1lên đến hàng trước khi bắt đầu 0621được phản ánh với phần 0621bổ sung và sau đó nhân lên 10 ⁴⁴⁶ và tăng dần.

“...’b⁴48;ĖŒṙḂ×7‘s15m€0F;“¡©£¢‘Ḍ×ȷ446‘ - Link: no arguments
“...’                                  - base 250 number
     b⁴                                - to base 16
       48;                             - prepend a 48
          Ė                            - enumerate [[1,48],[2,12],[3,3],[4,12],[5,3],...
           Œṙ                          - run-length decode (48 1s then 12 2s then ...)
             Ḃ                         - modulo by 2 (vectorises) evens->0 odds->1
              ×7                       - multiply by 7 (vectorises)
                ‘                      - increment (vectorises) - now all 8s and 1s
                 s15                   - split into chunks of length 15
                    m€0                - reflect each chunk
                       F               - flatten
                         “¡©£¢‘        - code-page indices = [0,6,2,1]
                        ;              - concatenate
                               Ḍ       - from decimal list to number
                                 ȷ446  - 10^446
                                ×      - multiply
                                     ‘ - increment

Than , 107 104 98 96 87 79 byte

Ｅ³⁰✂”}∧Pt→8⌕ＬＪε`‽∨↑¬KαfＧⅉKＭκ⎆wp◧⪫⊘^≦#⁸¹"π✂×OγX‹nI”×ι¹⁵×⊕ι¹⁵‖ＣＭ²⁸←621Ｍ²⁵¦¹⁴1ＵＢ0

Hãy thử trực tuyến! Liên kết đến mã dài dòng để giải thích

Proton , 368 byte

s=(map("8"&(*),[93,6,6,1,1,6,2,2,6,3,3,6,3,3,6,4,4,6,5,5,6,6,6,6,18,6,18,6,18,7,16,4,3,16,3,4,14,4,4,12,4,4,8,4,4,4,4,4,4,4,4,4,5,5,5,5,8,6,2]),map("1"&(*),[24,24,6,10,6,5,10,5,4,10,4,4,10,4,3,10,3,3,8,3,3,6,3,3,3,3,3,3,3,3,3,1,3,3,2,3,3,3,3,3,5,4,4,7,14,9,12,11,10,13,8,15,4,17,2,20,23,26,44]))
q=''.join(s[0][i]+s[1][i]for i:0..len(s[0]))
print(q+'0621'+'0'*445+'1')

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

Ruby , 180 byte

s=0;"".unpack('H*')[0].split(?f).map{|a|a.chars.map{|c|s^=2**c.to_i(16)};t=("%015b"%s).gsub ?0,?8;$><<t+t.reverse};puts'0621'+?0*445+?1

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

178 byte + 2 byte cho -Kn(buộc mã hóa ASCII.)

43 ký tự chủ yếu không thể in ở giữa các trích dẫn đầu tiên. Hexdump:

00000000: 733d 300a 22ff f012 3456 789a bff5 f6f7  s=0."...4Vx.....
00000010: ff8f 4f3f 012f ff8b fef7 af69 df45 8cf0  ..O?./.....i.E..
00000020: 1237 bf6a f59f 48f2 37f1 6f04 5f3f 12f0  .7.j..H.7.o._?..
00000030: 222e 756e 7061 636b 2827 482a 2729 5b30  ".unpack('H*')[0
00000040: 5d2e 7370 6c69 7428 3f66 292e 6d61 707b  ].split(?f).map{
00000050: 7c61 7c61 2e63 6861 7273 2e6d 6170 7b7c  |a|a.chars.map{|
00000060: 637c 735e 3d32 2a2a 632e 746f 5f69 2831  c|s^=2**c.to_i(1
00000070: 3629 7d3b 743d 2822 2530 3135 6222 2573  6)};t=("%015b"%s
00000080: 292e 6773 7562 203f 302c 3f38 3b24 3e3c  ).gsub ?0,?8;$><
00000090: 3c74 2b74 2e72 6576 6572 7365 7d0a 7075  <t+t.reverse}.pu
000000a0: 7473 2730 3632 3127 2b3f 302a 3434 352b  ts'0621'+?0*445+
000000b0: 3f31                                     ?1

Làm sao?

Mọi người khác đang thực hiện mã hóa chiều dài chạy, vì vậy tôi muốn thử một cái gì đó khác biệt.

Phiên bản "hình ảnh" được định dạng của nguyên tố có thể được tách thành hai phần - lưới 30x30 gồm 8 và 1, và phần thứ hai chủ yếu là các số không có thể được mã hóa cứng. Tập trung vào phần đầu tiên, chúng tôi quan sát rằng nó đối xứng xuống trung tâm, vì vậy nếu chúng tôi có thể tạo ra một nửa bên trái thì chúng tôi chỉ có thể in một nửa của mỗi dòng với mặt trái của nó.

Một nửa của một dòng dài 15 ký tự. Nếu chúng ta thay số 8 bằng số 0, mỗi dòng có thể được hiểu là số nhị phân 15 bit. Thuận tiện, phần lớn khoảng cách chỉnh sửa giữa mỗi dòng liên tiếp là nhỏ, vì vậy tôi quyết định thực hiện giải pháp của mình bằng cách lưu trữ dòng đầu tiên s( 888888888888888chỉ trở thành 0) và áp dụng một loạt các thao tác lật bit s, in kết quả mỗi lần .

Vì mỗi dòng dài 15 bit, tôi đã mã hóa các hoạt động này dưới dạng các chữ số thập lục phân - ví dụ: nếu hoạt động là b(hoặc 11), thì chúng tôi lật bit 11. Một số dòng khác nhau nhiều hơn một bit, vì vậy chúng yêu cầu một chuỗi thập lục phân chữ số. Chúng ta còn lại một chút ( f) vì vậy chúng ta có thể sử dụng nó như một dấu phân cách giữa các chuỗi này và cũng như một giá trị "không làm gì". Ví dụ dưới đây (bạn có thể thấy những dòng này trong bài được tham chiếu trong câu hỏi):

Line 3: 000000000000000
Line 4: 000111111111111  <-- flip bits 0 through b
Line 5: 000111111111111  <-- do nothing
Line 6: 000111111011111  <-- flip bit 5

Để kết hợp tất cả lại, chúng ta sẽ mã hóa 0123456789ab, sau đó tách ra f, không làm gì với f, sau đó 5. Điều này hoạt động bởi vì chúng tôi sẽ thực hiện .split(?f)sau để có được từng nhóm hoạt động theo dòng, sẽ mang lại kết quả ["0123456789ab", "", "5"]và ""sẽ là không hoạt động.

Sự khác biệt giữa các dòng 3 và 4 ở trên là tập hợp chỉnh sửa dài nhất và khoảng cách chỉnh sửa giữa hai dòng liên tiếp thường là 0-2, vì vậy tôi sẽ nói rằng mã hóa này khá rẻ, mặc dù tôi chắc chắn rằng nó có thể được cải thiện.

Toàn bộ chuỗi được mã hóa kết thúc là fff0123456789abff5f6f7ff8f4f3f012fff8bfef7af69df458cf01237bf6af59f48f237f16f045f3f12f0(86 byte), sẽ nhận được toàn bộ lưới 30x30. Nhưng chúng ta vẫn chưa xong ...

Các chữ số thập lục phân có thể được biểu thị bằng 4 bit ( b-> 1100, v.v.) Điều đó có nghĩa là nếu chúng ta sẵn sàng mã hóa chuỗi 4 bit của mình cùng một lúc thay vì sử dụng byte, chúng ta có thể cắt một nửa độ dài của chuỗi. Vì vậy, đó là những gì tôi đã làm - hexdump hiển thị chuỗi được biểu thị bằng 43 byte. Sau đó, nó chỉ là vấn đề của việc sử dụng Ruby tiện lợi String # giải nén với H*(giải thích như chuỗi hex, cao nibble đầu tiên) để mở rộng chuỗi 43 byte vào phiên bản 86-byte chúng ta biết và tình yêu, và Looping trên mỗi bộ hoạt động lật bit - cho chuỗi được lưu trữ của chúng tôi svà một thao tác cchúng tôi thực hiện s ^ 2**c.to_i(16)để lật bit tương ứng.

Sau khi hoàn thành mỗi bộ chỉnh sửa, chúng tôi đệm nhị phân kết quả thành 15 bit, chuyển tất cả các số 0 trở về 8 và in kết quả và ngược lại. Như đã lưu ý trước đó, phần của số sau lưới 30x30 có thể được mã hóa cứng, vì vậy chúng tôi làm như vậy puts'0621'+?0*445+?1.

Chuỗi được mã hóa cuối cùng không có khả năng hoạt động trên TIO, vì vậy phiên bản TIO sử dụng các lối thoát, vẫn hoạt động nhưng dài hơn.

Python 2 , 760 523 329 205 196 byte

-237 byte nhờ Stephen. -124 byte nhờ Jonathan Frech.

print''.join((ord(j)-34)*'81'[i%2]for i,j in enumerate(":(:((#,#(('$,$'(&%,%&(&%,%&(%&,&%(%'*'%(%(((%(%4%(%4%(%4%)%2%&#%%2%%$&%0%&%&%.%&'&&*&&)&0&+&.&-&,&/&*&1'&'3'$'6*9(<$N"))+'0621'+'0'*445+'1'

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

CJam, 532 412 340 231 210 209 byte

". $ MBZp & 8OIoLs7Rv / BEqN # 1r ~ E $ O% 6 ^ UO = \ z: (Iw] l \ LQ.g.aWf + {2; trên | YP'y $: Lc $ i $ GMCg & mRs # y0 Z, C | Hf6; b / o-0 | FNK5R: OIi} {'`CJ} LOXMSA, & vzl5scm5y0 {om = A _ # / wF"' # fm92bs: A; "6NLkB) h% @ u "'# fm92bYb2f + {[A / (\ s: A;)]}% e ~' 0445 * 1

Dùng thử trực tuyến

Mã hóa chiều dài chạy được mở rộng từ cơ sở 92 (Cơ sở 250 dẫn đến ký tự đa bào nên phải điều chỉnh). Ngoài ra, 4341089843357287864910309744850519376được mở rộng từ cơ sở 92 và chuyển đổi thành nhị phân. 1 có nghĩa là độ dài chạy là hai chữ số, 0 có nghĩa là một chữ số. Ví dụ: 4 chữ số đầu tiên của biểu diễn nhị phân là 1101 vì bốn lần chạy đầu tiên là [93,8],[24,1],[6,8],[24,1](93 8, 24 1, v.v ...)

JavaScript, 454 450 332 207 204 byte

-4 byte nhờ Stephen. -125 byte nhờ Shaggy và Dom Hastings.

_=>[...`]






,`].map((j,i)=>'81'[i%2].repeat(j.charCodeAt())).join``+0+621+"0".repeat(445)+1

Có một khối lượng thuyền không thể in được trong câu trả lời này, vì vậy đây là một hexdump:

00000000: 5f3d 3e5b 2e2e 2e60 5d18 0618 0606 010a  _=>[...`].......
00000010: 0106 0605 020a 0205 0604 030a 0304 0604  ................
00000020: 030a 0304 0603 040a 0403 0603 0508 0503  ................
00000030: 0603 0606 0603 0603 1203 0603 1203 0603  ................
00000040: 1203 0703 1003 0401 0303 1003 0302 0403  ................
00000050: 0e03 0403 0403 0c03 0405 0404 0804 0407  ................
00000060: 040e 0409 040c 040b 040a 040a 0408 040f  ................
00000070: 0504 0511 0502 0514 0817 061a 022c 605d  .............,`]
00000080: 2e6d 6170 2828 6a2c 6929 3d3e 2738 3127  .map((j,i)=>'81'
00000090: 5b69 2532 5d2e 7265 7065 6174 286a 2e63  [i%2].repeat(j.c
000000a0: 6861 7243 6f64 6541 7428 2929 292e 6a6f  harCodeAt())).jo
000000b0: 696e 6060 2b30 2b36 3231 2b22 3022 2e72  in``+0+621+"0".r
000000c0: 6570 6561 7428 3434 3529 2b31            epeat(445)+1

f=
_=>[...`]






,`].map((j,i)=>'81'[i%2].repeat(j.charCodeAt())).join``+0+621+"0".repeat(445)+1

document.write(f())

JavaScript (ES6), 206 205 204 203 198 197 194 byte

Đến với điều này trong khi làm việc với giải pháp của i cri everytim , cho rằng nó đủ khác biệt để đảm bảo đăng bài trên chính nó.

Điều này bao gồm tải không thể in được giữa ]và ,vì vậy hãy theo liên kết TIO bên dưới để xem nó với các lối thoát Unicode (mỗi chuỗi gồm \u4 chữ số được tính là 1 byte).

_=>`],0621ƽ1`.replace(/\D/g,(x,y)=>"810"[y<122?y&1:2].repeat(x.charCodeAt()))

Dùng thử trực tuyến

MATLAB / Octave , 319 318 byte

Đây là nỗ lực đầu tiên của tôi ở thử thách này. Vẫn còn một chút lớn và có thể có nhiều cách hiệu quả hơn để làm điều đó, nhưng tôi nghĩ dù sao tôi cũng sẽ đăng nó vì phương pháp này thú vị hơn là chỉ nén nó.

for i=reshape('|871%871%8%1 8)1 8%1%8$1!8)1!8$1%8#1"8)1"8#1%8#1"8)1"8#1%8"1#8)1#8"1%8"1$8''1$8"1%8"1%8%1%8"1%8"118"1%8"118"1%8"118"1&8"1/8"1#8 1"8"1/8"1"8!1#8"1-8"1#8"1#8"1+8"1#8$1#8#1''8#1#8&1#8-1#8(1#8+1#8*1#8)1#8,1#8''1#8.1$8#1$801$8!1$831''861%891!8K1 0 6 2 1~0~0~0~0`0 1',2,[]);fprintf(repmat(i(2),1,i(1)-31));end

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

Phương pháp được sử dụng ở đây là sử dụng sơ đồ sắp xếp Run-length-Encoding.

Chúng tôi bắt đầu với số ban đầu và đếm số chữ số liên tiếp. Chúng được viết trong kết quả dưới đây là số đếm được theo sau trực tiếp bởi chữ số (khoảng cách được phân tách cho rõ ràng).

938 241 68 241 68 61 8 101 8 61 68 51 28 101 28 51 68 41 38 101 38 41 68 41 38 101 38 41 68 31 48 101 48 31 68 31 58 81 58 31 68 31 68 61 68 31 68 31 188 31 68 31 188 31 68 31 188 31 78 31 168 31 48 1 38 31 168 31 38 21 48 31 148 31 48 31 48 31 128 31 48 51 48 41 88 41 48 71 48 141 48 91 48 121 48 111 48 101 48 131 48 81 48 151 58 41 58 171 58 21 58 201 88 231 68 261 28 441 0 6 2 1 4450 1

Nếu bất kỳ giá trị nào lớn hơn 95, chúng tôi sẽ chia thành nhiều phần từ 95 trở xuống - điều này chỉ xảy ra với các số 0 0, thay vào đó trở thành bốn bộ 95 0 và một bộ 65 0. Chúng tôi cũng đệm bất kỳ số nào nhỏ hơn 10 bằng 0 để làm cho tất cả các yếu tố dài ba ký tự. Điều này mang lại với các không gian được loại bỏ:

938241068241068061018101018061068051028101028051068041038101038041068041038101038041068031048101048031068031058081058031068031068061068031068031188031068031188031068031188031078031168031048011038031168031038021048031148031048031048031128031048051048041088041048071048141048091048121048111048101048131048081048151058041058171058021058201088231068261028441010016012011950950950950650011

Nhìn nhận lại vào thời điểm này tôi có thể đã thực hiện bước này trước khi hợp nhất tất cả lại với nhau, nhưng bạn có thể sống và học hỏi. Chúng tôi làm một điều gì đó thông minh là lấy số đếm cho mỗi nhóm (2 chữ số) và chúng tôi thêm 31. Vì tất cả chúng đều <96, số kết quả là giá trị ASCII cho một ký tự có thể in (32 đến 126). Cung cấp cho chúng tôi số lượng:

|7%7%% ) %%$!)!$%#")"#%#")"#%"#)#"%"$'$"%"%%%"%"1"%"1"%"1"&"/"# ""/""!#"-"#"#"+"#$##'##&#-#(#+#*#)#,#'#.$#$0$!$3'6%9!K    ~~~~` 

Sau một chút định hình lại trong MATLAB để thuận tiện hơn cho việc giải mã, và sau đó cũng thoát các 'ký tự bằng ''(nếu không MATLAB chia chuỗi ký tự chuỗi ở đó), chúng ta còn lại chuỗi thông minh:

|871%871%8%1 8)1 8%1%8$1!8)1!8$1%8#1"8)1"8#1%8#1"8)1"8#1%8"1#8)1#8"1%8"1$8''1$8"1%8"1%8%1%8"1%8"118"1%8"118"1%8"118"1&8"1/8"1#8 1"8"1/8"1"8!1#8"1-8"1#8"1#8"1+8"1#8$1#8#1''8#1#8&1#8-1#8(1#8+1#8*1#8)1#8,1#8''1#8.1$8#1$801$8!1$831''861%891!8K1 0 6 2 1~0~0~0~0`0 1

Đó là gốc của mã. Trong mã, tất cả những gì tôi làm là định hình lại mảng thành chuỗi 2D với 128 cặp ký tự. Đối với mỗi cặp, ký tự đầu tiên bị trừ 31, và sau đó ký tự thứ hai được hiển thị nhiều lần.

Kết quả là nguyên tố ban đầu:

888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888111111111111111111111111888888111111111111111111111111888888111111811111111118111111888888111118811111111118811111888888111188811111111118881111888888111188811111111118881111888888111888811111111118888111888888111888881111111188888111888888111888888111111888888111888888111888888888888888888111888888111888888888888888888111888888111888888888888888888111888888811188888888888888881118888188811188888888888888881118881188881118888888888888811188881118888111888888888888111888811111888811118888888811118888111111188881111111111111188881111111118888111111111111888811111111111888811111111118888111111111111188881111111188881111111111111118888811118888811111111111111111888881188888111111111111111111118888888811111111111111111111111888888111111111111111111111111118811111111111111111111111111111111111111111111062100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

Chỉnh sửa:

• sắp xếp lại chuỗi ma thuật để tôi có thể thoát khỏi sự hoán vị sau khi định hình lại. Lưu một byte.

05AB1E , 76 byte

•ŒÆÿ¹т£Ƶ‘β\,ä¸γλaXë«Š¸þaγG(žÃÇ…»šKþÈ/?`'•20BS20öDg81s∍Ss×J30ôø.∞0D445×621s1J

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

Lấy trộm cái này từ Dennis:

888888888888888811111111111111
888888888888888888111111111111
888888888888888888811111111111
888111111111111888881111111111
888111111111111118888111111111
888111111111111111888811111111
888111111888888111188881111111
888111188888888881118888111111
888111888888888888111888811111
888118888888888888811188881111
888111111188888888811118881111
888111111118888888881111888111
888111111111888888881111888811
888111111111888888881111188811
888111111111888888881111118881

Nhận thấy nó luôn xen kẽ giữa 8 và 1, vì vậy tôi đã đếm độ dài của mỗi lần chạy (Cơ sở 20):

['G', 'E', 'I', 'C', 'J', 'B', '3', 'C', '5', 'A', '3', 'E', '4', '9', '3', 'F', '4', '8', '3', '6', '6', '4', '4', '7', '3', '4', 'A', '3', '4', '6', '3', '3', 'C', '3', '4', '5', '3', '2', 'E', '3', '4', '4', '3', '7', '9', '4', '3', '4', '3', '8', '9', '4', '3', '3', '3', '9', '8', '4', '4', '2', '3', '9', '8', '5', '3', '2', '3', '9', '8', '6', '3', '1']

Kết hợp tất cả lại với nhau và chuyển đổi nó thành số nguyên cơ bản 10:

3954184379309026812828704944878416720438306456270310298603957651230861078960874182787979106461

Nén nó thêm vào cơ sở-255:

ŒÆÿ¹т£Ƶ‘β\,ä¸γλaXë«Š¸þaγG(žÃÇ…»šKþÈ/?`'

Sau đó, sau khi tạo bit nén ... Chúng ta chỉ cần thao tác nó trở lại ban đầu ..

20B                                 # Back to base 20.
   S                                # Each char separate...
    20ö                             # As their base 10 values...
       Dg81s∍                       # Extend '81' to the length of the array.
             Ss×J                   # Push that many 8 or 1's as told by the array.
                 30ôø.∞             # Split by the symmetrical pattern, flip it, mirror.
                       0D445×621s1  # Create the part that doesn't fit into a pattern.
                                  J # Join whole stack together.

Đầu ra cuối cùng:

88888888888888888888888888888
88888888888888888888888888888
88888888888888888888888888888
88811111111111111111111111888
88811111111111111111111111888
88811111181111111118111111888
88811111881111111118811111888
88811118881111111118881111888
88811118881111111118881111888
88811188881111111118888111888
88811188888111111188888111888
88811188888811111888888111888
88811188888888888888888111888
88811188888888888888888111888
88811188888888888888888111888
88881118888888888888881118888
18881118888888888888881118881
18888111888888888888811188881
11888811188888888888111888811
11188881111888888811118888111
11118888111111111111188881111
11111888811111111111888811111
11111188881111111118888111111
11111118888111111188881111111
11111111888881118888811111111
11111111188888188888111111111
11111111111888888811111111111
11111111111188888111111111111
11111111111111811111111111111
11111111111111111111111111111062100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

C (gcc) , 277 byte

Tôi có cảm giác rằng chuỗi có thể được rút ngắn bằng cách nào đó.

#define F(c,n)for(c=0;c<n;c++)
i,j,k;r(d,n){F(k,n)printf("%d",d);}f(){r(8,90);F(i,128)F(j,6)r(("8111i8111i8915i8=1=i8?1Mi8?1Mi8@1mi8P1oi8p1pi8pppi8pppi8pppi@opPm?opPMOmp@Omip8@iRpR8a41a4Q81i21@1m11O1O11mR@11id811Qp2111p1111="[i]-49>>j)&1?8:1,1);r(1,42);printf("0621%0446d",1);}

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

Perl 5 , 307 byte

$d=1;print((map{($d^=9)x$_}(93,24,6,24,6,6,1,10,1,6,6,5,2,10,2,5,6,4,3,10,3,4,6,4,3,10,3,4,6,3,4,10,4,3,6,3,5,8,5,3,6,3,6,6,6,3,6,3,18,3,6,3,18,3,6,3,18,3,7,3,16,3,4,1,3,3,16,3,3,2,4,3,14,3,4,3,4,3,12,3,4,5,4,4,8,4,4,7,4,14,4,9,4,12,4,11,4,10,4,13,4,8,4,15,5,4,5,17,5,2,5,20,8,23,6,26,2,44)),0,621,0 x445,1)

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

Bong bóng , 88 byte

00000000: edc9 310a 0250 10c4 d02b fdb1 90dc ff64  ..1..P...+.....d
00000010: 96c1 80a2 8885 60aa d97d 7cb3 3de8 75c5  ......`..}|.=.u.
00000020: 37ab 820a 51ee 9537 942a 55c4 aaec 76b4  7...Q..7.*U...v.
00000030: cfb5 1cdc 33dd 908b ac1c 74a0 894e 03c8  ....3.....t..N..
00000040: 11cc 99ab 9c1d c661 32c5 bad6 8aad 96d2  .......a2.......
00000050: b95e 76fe fd6e bb01                      .^v..n..

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

Ruby , 194 byte

$><<?8+"~:(:((#,#(('$,$'(&%,%&(&%,%&(%&,&%(%'*'%(%(((%(%4%(%4%(%4%)%2%&#%%2%%$&%0%&%&%.%&'&&*&&)&0&+&.&-&,&/&*&1'&'3'$'6*9(<$N".bytes.reduce(""){|s,x|s+(s[-1]==?8??1:?8)*(x-34)}+"0621"+?0*445+?1

Phần trên được mã hóa RLE, phần còn lại đơn giản là được mã hóa cứng.

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

Kotlin , 339 byte

val s="8J188J1888138<13881887148<14871886158<15861886158<15861885168<16851885178:178518851888188518851D8518851D8518851D8519851B85168315851B85158416851@85168516851>85168716861:861689168@168;168>168=168<168?168:168A1786178C1784178F1:8I188L148^130363231ǯ031"
fun x()=(0..s.length-1 step 2).map{i->(1..(s[i].toInt()-50)).map{print(s[i+1])}}

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

CJam ( 108 81 byte)

"u{èl>`#ö^½³ó!;kMðSÀËndEyvY3ÉÊÅBà#®"256bFbee{)*~}%"81"f=15/_Wf%zT6Y446,:!1

Bản demo trực tuyến

Trong trường hợp mã hóa ký tự bork ở trên, ở đây nó được mã hóa xxd:

0000000: 2275 1e7b e86c 3e60  8d23 80f6 5ebd b3f3  "u.{.l>`.#..^...
0000010: 213b 968d 6b4d f053  c0cb 6e64 1c45 7976  !;..kM.S..nd.Eyv
0000020: 5933 c9ca 8dc5 42e0  23ae 2232 3536 6246  Y3....B.#."256bF
0000030: 6265 657b 292a 7e7d  2522 3831 2266 3d31  bee{)*~}%"81"f=1
0000040: 352f 5f57 6625 7a54  3659 3434 362c 3a21  5/_Wf%zT6Y446,:!
0000050: 31                                        1

Lần chạy đầu tiên của 8 và 1 được chia thành nửa bên trái và chiều dài chạy được mã hóa thành chỉ các độ dài của các lần chạy xen kẽ. Các lần chạy hơn 24 được chia thành các lần chạy tối đa là 24, được phân tách bằng các lần chạy 0, do đó độ dài có thể được mã hóa cơ sở 25 và sau đó được mã hóa cơ sở 256 để đóng gói chúng.

JavaScript (ES2017), 287 byte

_=>"00000000000000000027wr2027wr2027a9ko261b7c23jerc23jerc1yjm0o1y8coo1y2ou01xx5q01xx5q01xx5q00yykxc9ull699d4au9dk75xffo1v2fgptj4fh8jrj3hhwvgfhmlev3hour5rhq24n3hqytj3hr4hdrhr8ykfhra0hr".replace(/.{6}/g,n=>parseInt(n,36).toString(2).replace(/0/g,8).padStart(30,8))+0+621+"0".repeat(445)+1

Sử dụng một cách tiếp cận hơi khác với câu trả lời của @icrieverytim . -10 byte nhờ đề xuất của @Shaggy sử dụng replacethay vì match!

f=
_=>"00000000000000000027wr2027wr2027a9ko261b7c23jerc23jerc1yjm0o1y8coo1y2ou01xx5q01xx5q01xx5q00yykxc9ull699d4au9dk75xffo1v2fgptj4fh8jrj3hhwvgfhmlev3hour5rhq24n3hqytj3hr4hdrhr8ykfhra0hr".replace(/.{6}/g,n=>parseInt(n,36).toString(2).replace(/0/g,8).padStart(30,8))+0+621+"0".repeat(445)+1
;
p.innerHTML=f()

pre{word-wrap:break-word;white-space:normal}

<pre id=p></pre>

/// , 260 byte

/;/88%//:/1&13%13"//9/\/\///7/"1#95/!!!!94/%""93/8889-/000009,/11#9'/###9&/#88"9%/"""9#/389"/1119!/-----0/'''''''##8%4#;4&"8%18""&11;188"1::1&#%1#"&#8"",8"&&"&&'&&'&&'&#3"'#"#13"'#"3,"##&#"#"'"#",7#7"7%",%#%"#%,%1#%7"",4#8784,8,8%%,#%%",;411;%%41106215555!0001

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

Không có gì thú vị khủng khiếp, chỉ là một số nén.

Toán học, 192 byte

Uncompress["1:eJxTTMoP8nRjZWCwoCUwxAGIl0VSZIEhi2wEXAgma4Eqa0GCrAW6rAW6rAWyJKYsulPRGGhBRLksNmmYy/HJonkOXStWaeTwgTGQ5JADD4mJTQRdGo2PysUwC1kA0yJDFPdgJjWoKHZJNB/hlMYhaYiaMgkDAzMjQ4NRMHSBIQDgQA6C"]

Xem: http://reference.wolfram.com/lingu/ref/Compress.html

Python 2 , 191 190 188 byte

s='0621'+'0'*445+'1'
a=1
for c in'L":&7(4%"%1%$%/$($-$*$+$,$)$.$\'$$($$%$#,#$#$#.#$"##0##!$#0#\'#2#&#2#&#2#&#&&&#&#%(%#&#$*$#&$#*#$&$#*#$&%"*"%&&!*!&&8&8}':s=`a`*(ord(c)-32)+s;a^=9
print s

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

Hiệu trưởng giống như câu trả lời của tôi ở đây