Выведите Троицкий зал Прайм

38

Основанный на этом вопросе Math.SE ; номер скопирован из этого ответа . Номер изначально из видео Numberphile , конечно.

Ваша задача - вывести следующее 1350-значное простое число:

888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888111111111111111111111111888888111111111111111111111111888888111111811111111118111111888888111118811111111118811111888888111188811111111118881111888888111188811111111118881111888888111888811111111118888111888888111888881111111188888111888888111888888111111888888111888888111888888888888888888111888888111888888888888888888111888888111888888888888888888111888888811188888888888888881118888188811188888888888888881118881188881118888888888888811188881118888111888888888888111888811111888811118888888811118888111111188881111111111111188881111111118888111111111111888811111111111888811111111118888111111111111188881111111188881111111111111118888811118888811111111111111111888881188888111111111111111111118888888811111111111111111111111888888111111111111111111111111118811111111111111111111111111111111111111111111062100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

При желании вы можете включить перевод строки в вывод.

правила

  • Это колмогорова-сложность , поэтому никаких отзывов .
  • Ваша программа должна завершиться в течение одного часа на стандартном компьютере - если она близко, я буду использовать мою для тестирования. Если ваша программа работает более минуты или не завершает работу на TIO, укажите время на вашем компьютере.
  • Это код-гольф , поэтому самый короткий код в байтах побеждает.
code-golf  kolmogorov-complexity  primes 
— Стивен
источник
3
«номер первоначально из видеофильма с номером», я думаю, что это от профессора Макки: P
— подземный
Как насчет этого премьер ?
— sergiol

Ответы:

31

Желе , 74 71 69 68 66 байт

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

Попробуйте онлайн!

Как это работает

Литерал “©ạ-3ṗÇñ"ỤḍV8żṢ?ḤsMVE[,Ṃƭ"ḞÇsẇʂ(ụFsẠʂẆŀṣ’заменяет все символы с их кодовыми точками в кодовой странице Jelly и интерпретирует результат как (bijective) число base-250, приводя к следующему целому числу.

103877200905186099028820568168804302565394743652609510039112658230540917082292838565138059974

Затем ḃ19преобразует это число в биективное основание 19, получая следующий массив цифр.

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

Теперь ĖŒṙперечисляет цифры и выполняет декодирование по длине прогона, получая следующий массив.

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

Затем ị⁾81индексирует в строку 81 , заменяя нечетные числа символом 8 , четное число - символом 1 . После s30этого результат разбивается на фрагменты длиной 30. Отображение одного фрагмента на строку приводит к следующему результату.

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

Теперь m0объединяет массив чанков с обращенной копией самого себя. После этого Zархивирует результат, перемещая строки и столбцы.

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

0является непарсируемой ниладой, поэтому результат before печатается (без разрывов строк), а возвращаемое значение устанавливается равным 0 .

62это еще один непарсируемый nilad, поэтому выводится результат before ( 0 ), а возвращаемое значение равно 62 .

ȷ446еще один непаренный нилад. 62 печатается, и возвращаемое значение устанавливается на 10 446 .

Наконец, ‘увеличивает результат. Окончательный результат ( 10 446 + 1 ) печатается после завершения программы.

— Деннис
источник
ооо круто, пожалуйста, добавьте объяснение: D
— HyperNeutrino
@HyperNeutrino, основываясь на результатах (но с моим полным отсутствием знаний о Jelly), происходит какое-то зеркалирование или что-то в этом роде
— Стивен
1
@Stephen Ну, я имею в виду, что сначала это какое-то причудливое число, а затем преобразование в «биективное основание чего-либо» (что бы это ни значило, я пойду разбираюсь в этом), а затем перечислю, а затем вычислю длину, а затем индексировать в [8, 1]... О, это умно! Я краду этот трюк, надеюсь, ты не возражаешь :))), а потом добавляешь все эти странные вещи 06210..01. приятно :)
— HyperNeutrino
2
@HyperNeutrino Добавлено объяснение.
— Деннис
За проголосовал только за «графику». Это довольно мило, жаль, что я не поняла Желе :)
— pinkfloydx33
7

SOGL V0.12 , 81 78 75 73 байта

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

Попробуй здесь!

Объяснение:

...“                 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
— dzaima
источник
6

Желе , 136 байт

“ßṪṭ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Ḍ

Попробуйте онлайн!

Пояснение (сокращенные цифры)

“ßṪṭ...*Ḣɲ’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 байт благодаря Деннису, использующему “...’литералы вместо обычных чисел

— HyperNeutrino
источник
“...’литералы сохраняют кучу байтов. tio.run/…
— Деннис
@ Деннис О боже, это еще более нечитаемо. Прекрасный! Благодарность! : D
— HyperNeutrino
0;6;2;1;кажется ужасно многословным.
— Волшебная Урна Осьминога
@MagicOctopusUrn Да, я мог бы немного сократить его; Я посмотрю на это когда-нибудь: P
— HyperNeutrino
6

Желе ,  133 84  73 байта

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

Попробуйте онлайн! (нижний колонтитул форматирует десятичное число с размерами, которые дают герб).

Как?

Длина зашифрованной формы двоичного формата с левой стороны герба 8и 1до строки до начала, 0621отраженного с 0621добавлением, а затем умноженного на 10 446 и увеличенного.

“...’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
— Джонатан Аллан
источник
4

Протон , 368 байт

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

Попробуйте онлайн!

— HyperNeutrino
источник
4

Рубин , 180 байт

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

Попробуйте онлайн!

178 байт + 2 байта для -Kn(принудительное кодирование ASCII)

43 преимущественно непечатаемых символа между первыми кавычками. 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

Как?

Все остальные делали кодирование длин серий, поэтому я хотел попробовать что-то другое.

Отформатированную версию «картинки» простого числа можно разделить на две части - сетку 30x30 из 8 и 1, и вторую секцию, состоящую в основном из нулей, которые могут быть жестко закодированы. Сосредоточив внимание на первой части, мы видим, что она симметрична по центру, поэтому, если мы можем произвести левую половину, мы можем просто напечатать половину каждой строки с ее обратной стороной.

Половина одной строки имеет длину 15 символов. Если мы заменим 8 на нули, каждая строка может быть интерпретирована как 15-битное двоичное число. Удобно, что по большей части расстояние редактирования между каждой последовательной строкой невелико, поэтому я решил реализовать свое решение, сохранив первую строку s( 888888888888888которая просто становится равной 0) и применив серию операций переворачивания битов s, каждый раз печатая результат ,

Поскольку каждая строка имеет длину 15 бит, я закодировал эти операции в виде шестнадцатеричных цифр - например, если операция b(или 11), то мы переворачиваем бит 11. Некоторые строки отличаются более чем на один бит, поэтому для них требуется строка шестнадцатеричного числа цифры. У нас остался один бит over ( f), поэтому мы можем использовать его как разделитель между этими строками, а также как значение «ничего не делать». Пример ниже (вы можете увидеть эти строки в сообщении, указанном в вопросе):

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

Чтобы сложить все это вместе, мы бы закодировали 0123456789ab, затем отделили f, ничего не делали f, тогда 5. Это работает , потому что мы будем делать .split(?f)позже , чтобы получить каждый набор операций по линии, которые принесут ["0123456789ab", "", "5"], и ""будет не-оп.

Разница между строками 3 и 4 выше - самый длинный набор правок, и расстояние редактирования между любыми двумя последовательными строками обычно составляет 0-2, поэтому я бы сказал, что это кодирование достаточно недорого, хотя я уверен, что оно может быть улучшенным.

В итоге вся закодированная строка fff0123456789abff5f6f7ff8f4f3f012fff8bfef7af69df458cf01237bf6af59f48f237f16f045f3f12f0(86 байт) получит всю сетку 30x30. Но мы еще не закончили ...

Шестнадцатеричные цифры могут быть представлены 4 битами ( b-> 1100и т. Д.). Это означает, что, если мы хотим кодировать нашу строку по 4 бита за раз, а не использовать байты, мы можем сократить длину строки пополам. Вот что я сделал - hexdump показывает строку, представленную в 43 байтах. После этого это просто вопрос использования изящной Руби распаковку String # в с помощью H*(интерпретировать как шестнадцатеричную строку, в первую очередь, высокий клев) для расширения 43-байтовой строки в 86-байтовую версию, которую мы знаем и любим, и зацикливать каждый набор операций. переворачивание битов - для нашей сохраненной строки sи операции, которую cмы делаем, s ^ 2**c.to_i(16)чтобы перевернуть соответствующий бит.

После того, как каждый набор изменений завершен, мы дополняем получаемый двоичный файл до 15 бит, переключаем все 0 обратно на 8 и печатаем результат и его реверс. Как отмечалось ранее, часть числа после сетки 30x30 может быть жестко закодирована, поэтому мы делаем это как puts'0621'+?0*445+?1.

Последняя закодированная строка не имеет возможности работать с TIO, поэтому версия TIO использует escape-коды, которые все еще работают, но длиннее.

— Легкая закуска
источник
3

Python 2 , 760 523 329 205 196 байт

-237 байтов благодаря Стивену. -124 байта благодаря Джонатану Фреху.

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'

Попробуйте онлайн!

— totallyhuman
источник
526 байтов , объявляя переменные для 8и 1и объединяя621
— Стивен
Ой. XD Я просто автоматизировал это, поэтому я не видел 621. Благодарность!
— полностью человек
2
205 байтов путем сжатия списка. Еще несколько, если вы хотите использовать только печатаемые байты.
— Джонатан Фрех
2

CJam, 532 412 340 231 210 209 байтов

»$ MBZp & 8OIoLs7Rv / BEqN # 1r ~ Е $ O 6% ^ УО = \ г: (IW] л \ LQ.g.aWf + {2; на | YP'y $:. Lc $ I $ GMCg & MRS # у0 * z` Z, C | Hf6; б / о-0 | FNK5R: УИР} { '`CJ} LOXMSA, & vzl5scm5y0 {ом = A _ # / ВФ"' # fm92bs: а; "6NLkB) ч% @ {u`hp_v + Ю.К. « '# fm92bYb2f + {[А / (\ S: А;)]}% е ~' 0445 * 1

Попробуйте онлайн

Кодирование длин серий увеличено с базы 92 (база 250 привела к многобайтовым символам, поэтому пришлось ее корректировать). Кроме того, 4341089843357287864910309744850519376расширен от базы 92 и преобразован в двоичный файл. 1 означает, что длина серии составляет две цифры, 0 означает, что это одна цифра. Например, первые 4 цифры двоичного представления - 1101, потому что первые четыре серии [93,8],[24,1],[6,8],[24,1](93 8, 24 1 и т. Д.)

— geokavel
источник
2

JavaScript, 454 450 332 207 204 байта

-4 байта благодаря Стивену. -125 байт благодаря Shaggy и Dom Hastings.

_=>[...`]






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

В этом ответе есть куча непечатных документов, так что вот 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())
Развернуть фрагмент

— totallyhuman
источник
Я считаю, что возвращение значения из функции будет правильным.
— Стивен
О, верно, спасибо. Не могли бы вы также сделать часть HTML? Я серьезно не знаю этого, я просто выбрал JS из-за аккуратного регулярного выражения. РЕДАКТИРОВАТЬ : Спасибо. : D
— полностью человек
Вы можете отменить кавычки вокруг последней, +'1'поскольку она уже есть Stringи +'0621'может быть +0+621!
— Дом Гастингс
1
222 байта - последний, обещаю!
— Лохматый
3
[...`]сводит меня с ума
— ETHproductions
2

JavaScript (ES6), 206 205 204 203 198 197 194 байта

Придумал это, работая над решением I Cri Everytim , подумал, что оно достаточно разное, чтобы публиковать его самостоятельно.

Это включает в себя загрузку непечатаемых символов между ]и таким ,образом, перейдите по ссылке TIO ниже, чтобы просмотреть его с экранированием Unicode (каждая последовательность, за которой \uследуют 4 цифры, считается как 1 байт).

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

Попробуйте онлайн

— мохнатый
источник
2

MATLAB / Octave , 319 318 байт

Это моя первая попытка решить эту проблему. Все еще немного большой и, вероятно, есть более эффективные способы сделать это, но я думал, что я отправлю это так или иначе, поскольку метод был более интересным, чем просто сжатие.

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

Попробуйте онлайн!

Метод, использованный здесь, заключается в том, чтобы использовать своего рода схему кодирования длины выполнения.

Мы начнем с исходного номера и посчитаем количество последовательных цифр. Они записаны в приведенном ниже результате как количество, за которым следует цифра (пробел отделен для ясности).

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

Если какое-либо из значений больше 95, мы разбиваем его на несколько частей по 95 или меньше - это происходит только для 445 0, которые вместо этого становятся четырьмя наборами 95 0 и набором 65 0. Мы также дополняем любое число меньше 10 символом 0, чтобы все элементы имели длину в три символа. Это приводит к удалению пробелов:

938241068241068061018101018061068051028101028051068041038101038041068041038101038041068031048101048031068031058081058031068031068061068031068031188031068031188031068031188031078031168031048011038031168031038021048031148031048031048031128031048051048041088041048071048141048091048121048111048101048131048081048151058041058171058021058201088231068261028441010016012011950950950950650011

Оглядываясь назад, я мог бы сделать этот шаг, прежде чем объединить все воедино, но как же вы живете и учитесь. Мы делаем что-то умное - взять счетчик для каждой группы (2 цифры) и добавляем 31. Поскольку все они <96, полученное число является значением ASCII для печатного символа (от 32 до 126). Дает нам количество:

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

После небольшого изменения формы в MATLAB, чтобы сделать его более удобным для декодирования, а затем экранирования 'символов с помощью ''(в противном случае MATLAB разбивает там строковые литералы), мы остаемся с умной строкой:

|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

Это корень кода. В коде все, что я затем делаю, это превращаю массив в двумерную строку с 128 парами символов. Для каждой пары первый символ вычитается 31, а затем второй символ отображается столько раз.

В результате получается оригинальное простое число:

888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888111111111111111111111111888888111111111111111111111111888888111111811111111118111111888888111118811111111118811111888888111188811111111118881111888888111188811111111118881111888888111888811111111118888111888888111888881111111188888111888888111888888111111888888111888888111888888888888888888111888888111888888888888888888111888888111888888888888888888111888888811188888888888888881118888188811188888888888888881118881188881118888888888888811188881118888111888888888888111888811111888811118888888811118888111111188881111111111111188881111111118888111111111111888811111111111888811111111118888111111111111188881111111188881111111111111118888811118888811111111111111111888881188888111111111111111111118888888811111111111111111111111888888111111111111111111111111118811111111111111111111111111111111111111111111062100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

Редактирование:

  • переставил волшебную строку, чтобы я мог избавиться от транспонирования после изменения формы. Сохраняет байт.
— Том Карпентер
источник
2

05AB1E , 76 байт

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

Попробуйте онлайн!

Украл это у Денниса:

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

Заметил, что он всегда чередуется между 8 и 1, поэтому я посчитал длины каждого прогона (база 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']

Сложил все это вместе и преобразовал в целое число с основанием 10:

3954184379309026812828704944878416720438306456270310298603957651230861078960874182787979106461

Сжал его дальше в базу-255:

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

Затем, после создания сжатого бита ... Мы просто должны манипулировать им обратно к оригиналу.

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.

Окончательный вывод:

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
— Урна волшебного осьминога
источник
2

C (gcc) , 277 байтов

У меня такое ощущение, что нить можно как-то укоротить.

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

Попробуйте онлайн!

— gastropner
источник
1

Perl 5 , 307 байт

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

Попробуйте онлайн!

— Xcali
источник
1

Жевательная резинка , 88 байт

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

Попробуйте онлайн!

— Дом Гастингс
источник
1

Рубин , 194 байта

$><<?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

Верхняя часть имеет RLE-кодировку, остальная часть просто закодирована.

Попробуйте онлайн!

— гигабайт
источник
1

Котлин , 339 байт

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

Попробуйте онлайн!

— jrtapsell
источник
1

CJam ( 108 81 байт)

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

Онлайн демо

В случае, если кодировка символов нарушает вышесказанное, здесь это 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

Начальный цикл 8 и 1 разделен на левую половину и длину цикла, закодированную как длина чередующихся серий. Последовательности более 24 разбиты на прогоны не более 24, разделенные прогонами 0, так что длины могут быть закодированы в формате base-25, а затем закодированы в base-256 для их упаковки.

— Питер Тейлор
источник
1

JavaScript (ES2017), 287 байт

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

Использует немного другой подход к ответу @icrieverytim . -10 байт благодаря предложению @Shaggy использовать replaceвместо 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>
Развернуть фрагмент

— Дом Гастингс
источник
1
— Лохматый
1

/// , 260 байт

/;/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

Попробуйте онлайн!

Ничего страшного, просто сжатие.

— Конор О'Брайен
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.