Wyjdź z Trinity Hall Prime

38

Na podstawie tego pytania Math.SE ; numer skopiowany z tej odpowiedzi . Oczywiście numer pochodzi z filmu Numberphile .

Twoim zadaniem jest wyprowadzenie następującej liczby pierwszej 1350-cyfrowej:

888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888111111111111111111111111888888111111111111111111111111888888111111811111111118111111888888111118811111111118811111888888111188811111111118881111888888111188811111111118881111888888111888811111111118888111888888111888881111111188888111888888111888888111111888888111888888111888888888888888888111888888111888888888888888888111888888111888888888888888888111888888811188888888888888881118888188811188888888888888881118881188881118888888888888811188881118888111888888888888111888811111888811118888888811118888111111188881111111111111188881111111118888111111111111888811111111111888811111111118888111111111111188881111111188881111111111111118888811118888811111111111111111888881188888111111111111111111118888888811111111111111111111111888888111111111111111111111111118811111111111111111111111111111111111111111111062100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

Opcjonalnie możesz dołączyć znaki nowej linii do wyniku.

Zasady

  • Jest to złożoność kolmogorowa , więc nie ma danych wejściowych.
  • Twój program musi zakończyć się w ciągu godziny na standardowym komputerze - jeśli jest blisko, użyję mojego do testowania. Jeśli Twój program działa dłużej niż minutę lub nie kończy się w TIO, podaj czas na komputerze.
  • To jest golf golfowy , więc wygrywa najkrótszy kod w bajtach.
code-golf  kolmogorov-complexity  primes 
— Stephen
źródło
3
„liczba oryginalnie z teledysku numerycznego”, myślę, że pochodzi ona od profesora mckee: P
— podziemny
— sergiol

Odpowiedzi:

31

Galaretka , 74 71 69 68 66 bajtów

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

Wypróbuj online!

Jak to działa

Dosłownie “©ạ-3ṗÇñ"ỤḍV8żṢ?ḤsMVE[,Ṃƭ"ḞÇsẇʂ(ụFsẠʂẆŀṣ’zastępuje wszystkie znaki ich punktami kodowymi na stronie kodowej Jelly i interpretuje wynik jako (dwuskładnikową) liczbę podstawową-250, uzyskując następną liczbę całkowitą.

103877200905186099028820568168804302565394743652609510039112658230540917082292838565138059974

Następnie ḃ19konwertuje tę liczbę na bazę dwusuwową 19, uzyskując następującą tablicę cyfr.

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

Teraz ĖŒṙwylicza cyfry i wykonuje dekodowanie długości przebiegu, uzyskując następującą tablicę.

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

Następnie ị⁾81indeksuje do łańcucha 81 , zastępując liczby nieparzyste znakiem 8 , a liczbą parzystą znakiem 1 . Następnie s30dzieli wynik na fragmenty o długości 30. Wyświetlając jeden fragment na linię, wynik wygląda następująco.

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

Teraz m0łączy tablicę fragmentów z odwróconą kopią samego siebie. Następnie Zzamyka wynik, transponując wiersze i kolumny.

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

0jest nieobliczalnym niladem, więc wynik z poprzedniej wypisywany jest (bez podziałów linii), a zwracana wartość jest ustawiona na 0 .

62jest kolejnym nieobliczalnym niladem, więc wypisywany jest wynik sprzed ( 0 ), a zwracana wartość to 62 .

ȷ446jest kolejnym nieporównywalnym niladem. 62 jest drukowane, a wartość zwracana jest ustawiona na 10 446 .

Wreszcie ‘zwiększa wynik. Wynik końcowy ( 10 446 + 1 ) jest drukowany po zakończeniu programu.

— Dennis
źródło
ooo spoko, proszę dodaj wyjaśnienie: D
— HyperNeutrino,
@HyperNeutrino na podstawie danych wyjściowych (ale z moim kompletnym brakiem wiedzy na temat galaretki), dzieje się trochę tworzenia kopii lustrzanych lub coś w tym rodzaju
— Stephen
1
@Stephen Cóż, mam na myśli najpierw jakąś wymyślną liczbę, a następnie konwersję na „coś bijective base” (cokolwiek to znaczy, wymyślę to), a następnie wyliczyć, a następnie długość, a następnie indeksować do [8, 1]... Och, to sprytne! Kradnę tę sztuczkę, mam nadzieję, że nie masz nic przeciwko :))), a potem tak, dodaj te wszystkie dziwne rzeczy 06210..01. fajnie :)
— HyperNeutrino,
2
@HyperNeutrino Dodano wyjaśnienie.
— Dennis,
Up głosował za samą „grafiką”. To jest całkiem słodkie, szkoda, że ​​nie rozumiem Jelly :)
— pinkfloydx33
7

SOGL V0.12 , 81 78 75 73 bajtów

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

Wypróbuj tutaj!

Wyjaśnienie:

...“                 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
źródło
6

Galaretka , 136 bajtów

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

Wypróbuj online!

Objaśnienie (numery skrócone)

“ßṪṭ...*Ḣɲ’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 bajtów dzięki Dennisowi używającemu “...’literałów zamiast normalnych liczb

— HyperNeutrino
źródło
“...’literały oszczędzają sporo bajtów. tio.run/…
— Dennis
@Dennis O rany, to jest jeszcze bardziej nieczytelne. Piękny! Dzięki! : D
— HyperNeutrino
0;6;2;1;wydaje się okropnie nieprzyjemny.
— Magic Octopus Urn
@MagicOctopusUrn Tak, prawdopodobnie mógłbym to trochę skrócić;
— Zajmę
6

Galaretka ,  133 84  73 bajtów

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

Wypróbuj online! (stopka formatuje liczbę dziesiętną o wymiarach określających herb).

W jaki sposób?

Długość kodowana w formacie binarnym lewej strony herbu 8i 1do rzędu przed tym, który zaczął się 0621odbijać z 0621dodanym, a następnie pomnożonym przez 10 446 i inkrementowanym.

“...’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
— Jonathan Allan
źródło
5

Węgiel drzewny , 107 104 98 96 87 79 bajtów

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

Wypróbuj online! Link do pełnego kodu wyjaśniającego

— Tylko ASCII
źródło
4

Proton , 368 bajtów

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

Wypróbuj online!

— HyperNeutrino
źródło
4

Rubinowy , 180 bajtów

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

Wypróbuj online!

178 bajtów + 2 bajty dla -Kn(wymusza kodowanie ASCII.)

43 głównie niedrukowalne znaki pomiędzy pierwszymi cytatami. 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

W jaki sposób?

Wszyscy inni kodowali długość przebiegu, więc chciałem spróbować czegoś innego.

Sformatowaną wersję „obrazu” liczby pierwszej można podzielić na dwie części - siatkę 30x30 z 8 i 1 oraz drugą sekcję składającą się głównie z zer, które można zakodować na stałe. Koncentrując się na pierwszej części, zauważamy, że jest symetryczna w dół w środku, więc jeśli możemy wyprodukować lewą połowę, możemy po prostu wydrukować połowę każdej linii z jej odwrotnością.

Połowa jednej linii ma 15 znaków. Jeśli zamienimy 8 na zera, każdą linię można interpretować jako 15-bitową liczbę binarną. Dogodnie, w przeważającej części odległość edycji między kolejnymi liniami jest niewielka, dlatego zdecydowałem się zaimplementować moje rozwiązanie, przechowując pierwszą linię s( 888888888888888która właśnie staje się 0) i stosując serię operacji odwracania bitów s, drukując wynik za każdym razem .

Ponieważ każda linia ma 15 bitów długości, zakodowałem te operacje jako cyfry szesnastkowe - na przykład, jeśli operacja to b(lub 11), to odwracamy bit 11. Niektóre linie różnią się więcej niż jednym bitem, więc wymagają ciągu szesnastkowego cyfry Pozostał nam jeden bit ( f), więc możemy go użyć jako separatora między tymi ciągami, a także jako wartości „nic nie rób”. Przykład poniżej (możesz zobaczyć te linie w poście, do którego odnosi się pytanie):

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

Aby umieścić to wszystko razem, chcemy zakodować 0123456789ab, a następnie oddzielić się f, nic nie robić z f, a następnie 5. Działa to, ponieważ zrobimy to .split(?f)później, aby uzyskać każdy zestaw operacji według linii, co przyniesie ["0123456789ab", "", "5"]i ""nie będzie żadnego działania.

Różnica między wierszami 3 i 4 powyżej jest zdecydowanie najdłuższym zestawem edycji, a odległość edycji między dowolnymi dwiema kolejnymi liniami wynosi zwykle 0-2, więc powiedziałbym, że to kodowanie jest dość niedrogie, chociaż jestem pewien, że może usprawniać się.

Cały zakodowany ciąg ma w końcu fff0123456789abff5f6f7ff8f4f3f012fff8bfef7af69df458cf01237bf6af59f48f237f16f045f3f12f0(86 bajtów), co pozwoli uzyskać całą siatkę 30x30. Ale jeszcze nie skończyliśmy ...

Cyfry szesnastkowe mogą być reprezentowane przez 4 bity ( b-> 1100itd.) Oznacza to, że jeśli chcemy zakodować nasz ciąg 4 bity naraz, zamiast używać bajtów, możemy skrócić jego długość o połowę. Tak właśnie zrobiłem - zrzut heksowy pokazuje ciąg reprezentowany w 43 bajtach. Potem wystarczy użyć sprytnego ciągu Ruby # rozpakuj za pomocą H*(interpretuj jako ciąg szesnastkowy, najpierw wysoki ciąg), aby rozwinąć 43-bajtowy ciąg do 86-bajtowej wersji, którą znamy i kochamy, i zapętlając każdy zestaw operacji przerzucanie bitów - dla naszego przechowywanego łańcucha si operacji cwykonujemy s ^ 2**c.to_i(16)odwrócenie odpowiedniego bitu.

Po zakończeniu każdego zestawu edycji wstawiamy wynikowy plik binarny do 15 bitów, przełączamy wszystkie zera z powrotem na 8 i wypisujemy wynik wraz z odwrotnością. Jak wspomniano wcześniej, część liczby po siatce 30x30 może być zakodowana na stałe, więc robimy to jako puts'0621'+?0*445+?1.

Ostatecznie zakodowany ciąg nie ma możliwości pracy z TIO, więc wersja TIO używa znaków zmiany znaczenia, które nadal działają, ale są dłuższe.

— Przekąska
źródło
3

Python 2 , 760 523 329 205 196 bajtów

-237 bajtów dzięki Stephenowi. -124 bajty dzięki Jonathanowi Frechowi.

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'

Wypróbuj online!

— całkowicie ludzki
źródło
526 bajtów przez deklarowania zmiennych dla 8a 1i łączenie621
— Stephen
O. XD Właśnie to zautomatyzowałem, więc nie widziałem 621. Dzięki!
— całkowicie ludzki,
2
205 bajtów przez kompresowanie listy. Jeszcze kilka, jeśli chcesz używać tylko bajtów do wydrukowania.
— Jonathan Frech,
2

CJam, 532 412 340 231 210 209 bajtów

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

Wypróbuj online

Kodowanie długości przebiegu rozszerzone z bazy 92 (baza 250 doprowadziła do znaków wielobajtowych, więc musiała się dostosować). Ponadto 4341089843357287864910309744850519376jest rozszerzany z bazy 92 i konwertowany na binarny. 1 oznacza, że ​​długość przebiegu składa się z dwóch cyfr, 0 oznacza jedną cyfrę. Na przykład pierwsze 4 cyfry reprezentacji binarnej to 1101, ponieważ pierwsze cztery przebiegi to [93,8],[24,1],[6,8],[24,1](93 8, 24 1 itd.)

— geokavel
źródło
2

JavaScript, 454 450 332 207 204 bajtów

-4 bajty dzięki Stephenowi. -125 bajtów dzięki Shaggy i Dom Hastings.

_=>[...`]






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

W tej odpowiedzi jest mnóstwo niezadrukowanych elementów, więc oto zrzut heksowy:

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())
Rozwiń fragment kodu

— całkowicie ludzki
źródło
Uważam, że zwrócenie wartości z funkcji byłoby poprawne.
— Stephen
Och, racja dzięki. Czy mógłbyś również wykonać część HTML? : PI poważnie nie wiem dużo o tym, właśnie wybrałem JS z powodu zgrabnego zastępowania wyrażeń regularnych. EDYCJA : Dzięki. : D
— całkowicie ludzki,
Możesz zanegować cytaty wokół ostatniego, +'1'ponieważ jest już Stringi +'0621'może być +0+621!
— Dom Hastings,
1
222 bajty - ostatni, obiecuję!
— Shaggy
3
[...`]wkurza mnie
— ETHproductions
2

JavaScript (ES6), 206 205 204 203 198 197 194 bajtów

Przyszło mi to do głowy, pracując nad rozwiązaniem i cri everytim, doszedłem do wniosku, że jest on na tyle inny, że wymaga samodzielnego opublikowania.

Obejmuje to ładunek niedrukowalnych znaków między ]i ,tak, a następnie kliknij łącze TIO poniżej, aby wyświetlić je ze znakami ucieczki Unicode (każda sekwencja \unastępujących po nich 4 cyfr liczy się jako 1 bajt).

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

Wypróbuj online

— Kudłaty
źródło
2

MATLAB / oktawa , 319 318 bajtów

To moja pierwsza próba tego wyzwania. Nadal jest trochę duży i prawdopodobnie istnieją bardziej wydajne sposoby, ale pomyślałem, że i tak opublikuję go, ponieważ metoda była bardziej interesująca niż tylko skompresowanie.

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

Wypróbuj online!

Zastosowana tutaj metoda polega na użyciu pewnego rodzaju schematu kodowania przebiegu.

Zaczynamy od oryginalnego numeru i liczymy liczbę kolejnych cyfr. Są one zapisywane w poniższym wyniku jako liczba, po której następuje bezpośrednio cyfra (spacja oddzielona dla przejrzystości).

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

Jeśli którakolwiek z wartości jest większa niż 95, dzielimy ją na wiele kawałków po 95 lub mniej - dzieje się tak tylko w przypadku 445 0, które zamiast tego stają się czterema zestawami 95 0 i zestawem 65 0. Wypełniamy również liczby mniejsze niż 10 cyfrą 0, aby wszystkie elementy miały długość trzech znaków. Daje to po usunięciu spacji:

938241068241068061018101018061068051028101028051068041038101038041068041038101038041068031048101048031068031058081058031068031068061068031068031188031068031188031068031188031078031168031048011038031168031038021048031148031048031048031128031048051048041088041048071048141048091048121048111048101048131048081048151058041058171058021058201088231068261028441010016012011950950950950650011

Z perspektywy czasu w tym momencie mogłem zrobić ten krok, zanim połączyłem to wszystko razem, ale czyż nie żyjesz i uczysz się. Robimy coś sprytnego, co polega na liczeniu dla każdej grupy (2 cyfry) i dodajemy 31. Ponieważ wszystkie mają <96, wynikowa liczba jest wartością ASCII dla drukowalnego znaku (32 do 126). Dając nam liczy:

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

Po drobnym przekształceniu w MATLAB-ie, aby uczynić go bardziej korzystnym do dekodowania, a następnie również 'znakami ucieczki ''(w przeciwnym razie MATLAB dzieli tam literały łańcuchowe), pozostaje nam sprytny ciąg:

|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

To jest rdzeń kodu. W kodzie wszystko, co wtedy robię, to przekształcić tablicę w ciąg 2D z 128 parami znaków. Dla każdej pary pierwszy znak jest odejmowany 31, a następnie drugi znak jest wyświetlany tyle razy.

Rezultatem jest pierwotna liczba pierwsza:

888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888111111111111111111111111888888111111111111111111111111888888111111811111111118111111888888111118811111111118811111888888111188811111111118881111888888111188811111111118881111888888111888811111111118888111888888111888881111111188888111888888111888888111111888888111888888111888888888888888888111888888111888888888888888888111888888111888888888888888888111888888811188888888888888881118888188811188888888888888881118881188881118888888888888811188881118888111888888888888111888811111888811118888888811118888111111188881111111111111188881111111118888111111111111888811111111111888811111111118888111111111111188881111111188881111111111111118888811118888811111111111111111888881188888111111111111111111118888888811111111111111111111111888888111111111111111111111111118811111111111111111111111111111111111111111111062100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

Edycje:

  • przestawił magiczny sznurek, abym mógł pozbyć się transpozycji po zmianie kształtu. Zapisuje bajt.
— Tom Carpenter
źródło
2

05AB1E , 76 bajtów

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

Wypróbuj online!

Ukradł to od Dennisa:

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

Zauważyłem, że zawsze zmienia się między 8 a 1, więc policzyłem długości każdego biegu (Baza 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']

Połącz to wszystko razem i przekonwertowałem na liczbę całkowitą base-10:

3954184379309026812828704944878416720438306456270310298603957651230861078960874182787979106461

Skompresowano go dalej do bazy-255:

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

Następnie, po utworzeniu skompresowanego bitu ... Musimy po prostu zmanipulować go z powrotem do oryginalnego ..

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.

Końcowe wyjście:

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
— Urna Magicznej Ośmiornicy
źródło
2

C (gcc) , 277 bajtów

Mam wrażenie, że sznurek można jakoś skrócić.

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

Wypróbuj online!

— gastropner
źródło
1

Perl 5 , 307 bajtów

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

Wypróbuj online!

— Xcali
źródło
1

Bubblegum , 88 bajtów

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

Wypróbuj online!

— Dom Hastings
źródło
1

Ruby , 194 bajty

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

Górna część jest zakodowana w RLE, reszta jest po prostu zakodowana na stałe.

Wypróbuj online!

— GB
źródło
1

Kotlin , 339 bajtów

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

Wypróbuj online!

— jrtapsell
źródło
1

CJam ( 108 81 bajtów)

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

Demo online

W przypadku, gdy kodowanie znaków pomija powyższe, tutaj jest kodowane 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

Początkowy przebieg 8s i 1s jest podzielony tylko na lewą połowę, a długość przebiegu jest zakodowana jako długość odcinków naprzemiennych. Przebiegi o długości większej niż 24 są podzielone na przebiegi o długości co najwyżej 24, oddzielone przebiegami o wartości 0, dzięki czemu długości mogą być zakodowane w podstawie-25, a następnie zakodowane w podstawie-256, aby je spakować.

— Peter Taylor
źródło
1

JavaScript (ES2017), 287 bajtów

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

Stosuje nieco inne podejście do odpowiedzi @icrieverytim . -10 bajtów dzięki sugestii @Shaggy'ego użycia replacezamiast 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>
Rozwiń fragment kodu

— Dom Hastings
źródło
1
— Shaggy
1

/// , 260 bajtów

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

Wypróbuj online!

Nic strasznie interesującego, tylko kompresja.

— Conor O'Brien
źródło
1

Python 2 , 191 190 188 bajtów

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

Wypróbuj online!

Ta sama zasada, co moja odpowiedź tutaj

— TFeld
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.