Ausgabe der Trinity Hall Prime

38

Basierend auf dieser Math.SE-Frage ; Nummer aus dieser Antwort kopiert . Die Nummer stammt natürlich aus einem Numberphile-Video .

Ihre Aufgabe ist es, die folgende 1350-stellige Primzahl auszugeben:

888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888111111111111111111111111888888111111111111111111111111888888111111811111111118111111888888111118811111111118811111888888111188811111111118881111888888111188811111111118881111888888111888811111111118888111888888111888881111111188888111888888111888888111111888888111888888111888888888888888888111888888111888888888888888888111888888111888888888888888888111888888811188888888888888881118888188811188888888888888881118881188881118888888888888811188881118888111888888888888111888811111888811118888888811118888111111188881111111111111188881111111118888111111111111888811111111111888811111111118888111111111111188881111111188881111111111111118888811118888811111111111111111888881188888111111111111111111118888888811111111111111111111111888888111111111111111111111111118811111111111111111111111111111111111111111111062100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

Optional können Sie Zeilenumbrüche in die Ausgabe einbeziehen.

Regeln

  • Das ist , also keine Eingabe.
  • Ihr Programm muss innerhalb einer Stunde auf einem Standardcomputer beendet sein - wenn es in der Nähe ist, verwende ich meins zum Testen. Wenn Ihr Programm länger als eine Minute ausgeführt wird oder unter TIO nicht beendet wird, geben Sie bitte die Uhrzeit auf Ihrem Computer an.
  • Das ist , also gewinnt der kürzeste Code in Bytes.
Stephen
quelle
3
"nummer ursprünglich aus einem numberphile video" ich denke es ist ursprünglich von professor mckee: P
undergroundmonorail
Was ist mit dieser Primzahl ?
Sergiol

Antworten:

31

Jelly , 74 71 69 68 66 Bytes

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

Probieren Sie es online!

Wie es funktioniert

Das Literal “©ạ-3ṗÇñ"ỤḍV8żṢ?ḤsMVE[,Ṃƭ"ḞÇsẇʂ(ụFsẠʂẆŀṣ’ersetzt alle Zeichen durch ihre Codepunkte in Jellys Codepage und interpretiert das Ergebnis als eine (bijektive) Basis-250-Zahl, die die folgende Ganzzahl ergibt.

103877200905186099028820568168804302565394743652609510039112658230540917082292838565138059974

Dann ḃ19wandelt diese Nummer bijektive Basis 19, die folgenden Ziffernarray ergibt.

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

Nun ĖŒṙlistet die Stellen und führt eine Lauflängen - Decodierung, die folgende Anordnung ergibt.

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

Dann wird ị⁾81die Zeichenfolge 81 indiziert , wobei ungerade Zahlen durch das Zeichen 8 und gerade durch das Zeichen 1 ersetzt werden . Anschließend wird s30das Ergebnis in Blöcke der Länge 30 aufgeteilt. Wenn Sie einen Block pro Zeile anzeigen, sieht das Ergebnis wie folgt aus.

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

Nun, m0verkettet die Anordnung der Stücke mit einer umgekehrten Kopie von sich selbst. Anschließend können Sie Zdas Ergebnis komprimieren und Zeilen und Spalten transponieren.

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

0ist ein nicht analysierbarer Nullwert, daher wird das Ergebnis von vorher gedruckt (ohne Zeilenumbrüche) und der Rückgabewert auf 0 gesetzt .

62ist ein weiterer nicht analysierbarer Nullwert, daher wird das Ergebnis von vor ( 0 ) gedruckt und der Rückgabewert auf 62 gesetzt .

ȷ446ist noch ein nicht zu analysierender Nilad. 62 wird gedruckt und der Rückgabewert auf 10 446 gesetzt .

Schließlich erhöht das Ergebnis. Das Endergebnis ( 10 446 + 1 ) wird gedruckt, wenn das Programm beendet ist.

Dennis
quelle
ooo cool bitte eine Erklärung hinzufügen: D
HyperNeutrino
@HyperNeutrino basierend auf der Ausgabe (aber mit meinem völligen Mangel an Jelly Wissen), gibt es einige Spiegelungen oder so ähnlich
Stephen
1
@Stephen Nun, ich meine, es ist zuerst eine ausgefallene Zahl und dann Umwandlung in "bijektive Basis etwas" (was auch immer das bedeutet, ich werde das herausfinden), und dann aufzählen, und dann Lauflänge und dann Index in [8, 1]... Oh, das ist schlau! Ich klaue diesen Trick, ich hoffe es macht dir nichts aus :))) und dann füge ja all das komische 06210..01 Zeug hinzu. nice :)
HyperNeutrino
2
@HyperNeutrino Eine Erklärung hinzugefügt.
Dennis
Up hat allein für die "Grafik" gestimmt. Das ist ziemlich süß, wünschte ich hätte Jelly verstanden :)
pinkfloydx33
7

SOGL V0.12 , 81 78 75 73 Bytes

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

Probieren Sie es hier aus!

Erläuterung:

...“                 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
quelle
6

Jelly , 136 Bytes

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

Probieren Sie es online!

Erklärung (Zahlen gekürzt)

“ßṪṭ...*Ḣɲ’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 Bytes dank Dennis mit “...’Literalen anstelle von normalen Zahlen

HyperNeutrino
quelle
“...’Literale sparen eine Menge Bytes. tio.run/…
Dennis
@ Tennis Oh meine Güte, das ist noch unleserlicher. Schön! Vielen Dank! : D
HyperNeutrino
0;6;2;1;scheint schrecklich wortreich.
Magic Octopus Urn
@MagicOctopusUrn Ja, ich könnte es wahrscheinlich ein bisschen verkürzen. Ich werde das irgendwann untersuchen: P
HyperNeutrino
6

Jelly ,  133 84  73 Bytes

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

Probieren Sie es online! (Fußzeile formatiert die Dezimalzahl mit den Abmessungen, die das Wappen ergeben).

Wie?

Eine lauflängenkodierte Form eines Binärformats auf der linken Seite des Wappens 8und 1bis zur Zeile vor der ersten, 0621die mit dem 0621Addierten wiedergegeben und dann mit 10 446 multipliziert und inkrementiert wird.

“...’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
quelle
5

Charcoal , 107 104 98 96 87 79 Bytes

E³⁰✂”}∧Pt→8⌕LJε`‽∨↑¬KαfGⅉKMκ⎆wp◧⪫⊘^≦#⁸¹"π✂×OγX‹nI”×ι¹⁵×⊕ι¹⁵‖CM²⁸←621M²⁵¦¹⁴1UB0

Probieren Sie es online! Link zum ausführlichen Code zur Erklärung

Nur ASCII
quelle
4

Proton , 368 Bytes

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

Probieren Sie es online!

HyperNeutrino
quelle
4

Ruby , 180 Bytes

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

Probieren Sie es online!

178 Bytes + 2 Bytes für -Kn(Erzwingt ASCII-Codierung.)

43 meist nicht druckbare Zeichen zwischen den ersten Anführungszeichen. 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

Wie?

Alle anderen haben eine Lauflängencodierung durchgeführt, deshalb wollte ich etwas anderes ausprobieren.

Die formatierte "Bild" -Version der Primzahl kann in zwei Teile unterteilt werden: ein 30x30-Raster mit 8 und 1 sowie einen zweiten Abschnitt mit meistens Nullen, die fest codiert werden können. Wenn wir uns auf den ersten Teil konzentrieren, stellen wir fest, dass er in der Mitte symmetrisch ist. Wenn wir also die linke Hälfte produzieren können, können wir einfach die Hälfte jeder Zeile mit der Rückseite drucken.

Die Hälfte einer Zeile besteht aus 15 Zeichen. Wenn wir die 8 durch Nullen ersetzen, kann jede Zeile als 15-Bit-Binärzahl interpretiert werden. Praktischerweise ist der Bearbeitungsabstand zwischen den aufeinanderfolgenden Zeilen zum größten Teil gering. Daher habe ich beschlossen, meine Lösung zu implementieren, indem ich die erste Zeile s( 888888888888888die gerade 0 wird) speicherte und eine Reihe von Bitumkehroperationen anwandte s, um das Ergebnis jedes Mal auszudrucken .

Da jede Zeile 15 Bit lang ist, habe ich diese Operationen als hexadezimale Ziffern codiert. Wenn die Operation beispielsweise b(oder 11) ist, wird Bit 11 umgedreht. Einige Zeilen unterscheiden sich um mehr als ein Bit, sodass eine hexadezimale Zeichenfolge erforderlich ist Ziffern. Wir haben noch ein Bit übrig ( f), damit wir es als Trennzeichen zwischen diesen Zeichenfolgen und als Wert für "do nothing" verwenden können. Beispiel unten (Sie können diese Zeilen in dem Beitrag sehen, auf den in der Frage verwiesen wird):

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

Zu setzen , dass alle zusammen, würden kodieren wir 0123456789ab, dann mit trennen f, nichts tun mit f, dann 5. Dies funktioniert, weil wir .split(?f)später jede Gruppe von Operationen zeilenweise abrufen werden, was sich nachteilig auswirkt ["0123456789ab", "", "5"]und ""ein No-Op ist.

Der Unterschied zwischen den obigen Zeilen 3 und 4 ist bei weitem der längste Satz von Bearbeitungen, und der Bearbeitungsabstand zwischen zwei aufeinanderfolgenden Zeilen beträgt normalerweise 0-2. Daher würde ich sagen, dass diese Codierung relativ kostengünstig ist, obwohl ich mir sicher bin, dass dies möglich ist verbessert werden.

Die gesamte codierte Zeichenfolge hat eine fff0123456789abff5f6f7ff8f4f3f012fff8bfef7af69df458cf01237bf6af59f48f237f16f045f3f12f0Größe von 86 Byte, wodurch das gesamte Raster von 30 x 30 erhalten wird. Aber wir sind noch nicht fertig ...

Hexadezimale Ziffern können durch 4 Bits ( b-> 1100usw.) dargestellt werden. Dies bedeutet, dass wir die Länge der Zeichenfolge halbieren können , wenn wir bereit sind, die Zeichenfolge 4 Bits gleichzeitig zu codieren, anstatt Bytes zu verwenden. So habe ich es gemacht - der Hexdump zeigt den String in 43 Bytes. Danach müssen Sie nur noch Rubys raffinierten String # unpack with H*(interpretieren als Hex-String, High Nibble First) verwenden, um den 43-Byte-String auf die 86-Byte-Version zu erweitern, die wir kennen und lieben, und alle Operationen in einer Schleife durchlaufen Bits spiegeln - für unsere gespeicherten String sund einer Operation ctun wir s ^ 2**c.to_i(16)das entsprechende Bit kippen.

Nachdem jeder Satz von Bearbeitungen abgeschlossen ist, füllen wir die resultierende Binärdatei mit 15 Bits auf, schalten alle Nullen auf 8 zurück und drucken das Ergebnis und seine Umkehrung. Wie bereits erwähnt, kann der Teil der Zahl nach dem 30x30-Raster fest codiert werden puts'0621'+?0*445+?1.

Die endgültig codierte Zeichenfolge kann nicht mit TIO bearbeitet werden. In der TIO-Version werden Escapes verwendet, die zwar noch funktionieren, aber länger sind.

Snack
quelle
3

Python 2 , 760 523 329 205 196 Bytes

-237 Bytes dank Stephen. -124 Bytes dank 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'

Probieren Sie es online!

total menschlich
quelle
526 Bytes durch Deklarieren von Variablen für 8und 1und Kombinieren621
Stephen
Oh. XD Ich habe es nur automatisiert, also habe ich das nicht gesehen 621. Vielen Dank!
Totalhuman
2
205 Bytes durch Komprimieren der Liste. Noch ein paar, wenn Sie nur druckbare Bytes verwenden möchten.
Jonathan Frech
2

CJam, 532 412 340 231 210 209 Bytes

". $ MBZp & 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; "'# fm92bYb2f + {[A / (\ s: A;)]}% e ~' 0445 * 1

Probieren Sie es online

Die Lauflängencodierung wurde von Basis 92 erweitert (Basis 250 führte zu Multibyte-Zeichen, musste also angepasst werden). Wird auch 4341089843357287864910309744850519376von der Basis 92 aus erweitert und in Binärdaten umgewandelt. Eine 1 bedeutet, dass die Lauflänge zweistellig ist, eine 0 bedeutet, dass es sich um eine Ziffer handelt. Zum Beispiel sind die ersten 4 Stellen der Binärdarstellung 1101, weil die ersten vier Läufe [93,8],[24,1],[6,8],[24,1](93 8er, 24er, etc ...) sind.

Geokavel
quelle
2

JavaScript, 454 450 332 207 204 Bytes

-4 Bytes danke an Stephen. -125 Bytes dank Shaggy und Dom Hastings.

_=>[...`]






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

Diese Antwort enthält eine Schiffsladung nicht druckbarer Dateien. Hier ist also ein 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())

total menschlich
quelle
Ich glaube, den Wert von einer Funktion zurückzugeben, würde gültig sein.
Stephen
Oh, richtig, danke. Könnten Sie bitte auch den HTML-Teil machen? : PI weiß im Ernst nicht viel davon, ich habe mich gerade für JS entschieden, weil ich ordentlich Regex ersetze. EDIT : Danke. : D
totalhuman
Sie können die Anführungszeichen um das letzte annullieren, +'1'da es bereits ein ist Stringund sein +'0621'kann +0+621!
Dom Hastings
1
222 Bytes - Letzteres verspreche ich!
Shaggy
3
[...`]macht mich so wütend
ETHproductions
2

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

Als ich bei der Arbeit an der Lösung von i cri everytim dabei war , stellte ich fest , dass sie unterschiedlich genug war, um das eigene Posten zu rechtfertigen.

Dies beinhaltet eine Menge nicht druckbarer Dateien zwischen dem ]und dem. Folgen Sie ,also dem TIO-Link unten, um sie mit Unicode- Escape- Zeichen anzuzeigen (jede Folge von \ugefolgt von 4 Ziffern zählt als 1 Byte).

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

Probieren Sie es online aus

Zottelig
quelle
2

MATLAB / Octave , 319 318 Bytes

Dies ist mein erster Versuch bei dieser Herausforderung. Immer noch ein bisschen groß und es gibt wahrscheinlich effizientere Möglichkeiten, dies zu tun, aber ich dachte, ich würde es trotzdem posten, da die Methode interessanter war, als es nur zu komprimieren.

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

Probieren Sie es online!

Die hier verwendete Methode besteht darin, ein Run-Length-Encoding-Schema zu verwenden.

Wir beginnen mit der ursprünglichen Nummer und zählen die Anzahl der aufeinander folgenden Ziffern. Diese werden im Ergebnis unten als Zählung direkt gefolgt von der Ziffer (aus Gründen der Übersichtlichkeit durch Leerzeichen getrennt) angegeben.

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

Wenn einer der Werte größer als 95 ist, teilen wir ihn in mehrere Abschnitte von 95 oder weniger auf - dies geschieht nur für die 445 0, die stattdessen vier Sätze von 95 0 und einen Satz von 65 0 ergeben. Wir füllen auch alle Zählungen, die kleiner als 10 sind, mit einer 0 auf, damit alle Elemente drei Zeichen lang sind. Dies ergibt mit den entfernten Leerzeichen:

938241068241068061018101018061068051028101028051068041038101038041068041038101038041068031048101048031068031058081058031068031068061068031068031188031068031188031068031188031078031168031048011038031168031038021048031148031048031048031128031048051048041088041048071048141048091048121048111048101048131048081048151058041058171058021058201088231068261028441010016012011950950950950650011

Im Nachhinein hätte ich diesen Schritt tun können, bevor ich alles zusammengeführt habe, aber du lebst und lernst. Wir machen etwas Kluges, indem wir die Anzahl für jede Gruppe (2 Ziffern) berechnen und 31 addieren. Da alle <96 sind, ist die resultierende Zahl der ASCII-Wert für ein druckbares Zeichen (32 bis 126). Geben Sie uns zählt von:

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

Nach einigem Umformen in MATLAB, um es für die Dekodierung günstiger zu machen, und dann auch mit Escape- 'Zeichen ''(ansonsten teilt MATLAB String-Literale dort auf), bleibt uns der clevere String:

|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

Das ist die Wurzel des Codes. Im Code ist alles, was ich dann tue, das Array in eine 2D-Zeichenfolge mit 128 Zeichenpaaren umzuformen. Für jedes Paar hat das erste Zeichen 31 subtrahiert, und dann wird das zweite Zeichen so oft angezeigt.

Das Ergebnis ist die ursprüngliche Primzahl:

888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888111111111111111111111111888888111111111111111111111111888888111111811111111118111111888888111118811111111118811111888888111188811111111118881111888888111188811111111118881111888888111888811111111118888111888888111888881111111188888111888888111888888111111888888111888888111888888888888888888111888888111888888888888888888111888888111888888888888888888111888888811188888888888888881118888188811188888888888888881118881188881118888888888888811188881118888111888888888888111888811111888811118888888811118888111111188881111111111111188881111111118888111111111111888811111111111888811111111118888111111111111188881111111188881111111111111118888811118888811111111111111111888881188888111111111111111111118888888811111111111111111111111888888111111111111111111111111118811111111111111111111111111111111111111111111062100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

Bearbeitungen:

  • Die magische Saite wurde neu angeordnet, sodass ich nach der Umformung eine Transponierte loswerden konnte. Speichert ein Byte.
Tom Carpenter
quelle
2

05AB1E , 76 Bytes

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

Probieren Sie es online!


Habe das von Dennis gestohlen:

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

Bemerkt, dass es immer zwischen 8 und 1 wechselt, also habe ich die Länge jedes Laufs gezählt (Basis 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']

Fügte alles zusammen und wandelte es in eine Ganzzahl zur Basis 10 um:

3954184379309026812828704944878416720438306456270310298603957651230861078960874182787979106461

Komprimiert es weiter in base-255:

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

Nachdem Sie das komprimierte Bit erstellt haben, müssen Sie es nur wieder auf das Original zurücksetzen.

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.

Endgültige Ausgabe:

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
Magische Kraken-Urne
quelle
2

C (gcc) , 277 Bytes

Ich habe das Gefühl, dass die Saite irgendwie gekürzt werden könnte.

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

Probieren Sie es online!

Gastropner
quelle
1

Perl 5 , 307 Bytes

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

Probieren Sie es online!

Xcali
quelle
1

Bubblegum , 88 Bytes

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

Probieren Sie es online!

Dom Hastings
quelle
1

Ruby , 194 Bytes

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

Der obere Teil ist RLE-codiert, der Rest ist einfach fest codiert.

Probieren Sie es online!

GB
quelle
1

Kotlin , 339 Bytes

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

Probieren Sie es online!

jrtapsell
quelle
1

CJam ( 108 81 Bytes)

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

Online-Demo

Für den Fall, dass die obige Zeichencodierung fehlschlägt, ist sie hier xxd-codiert:

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

Der anfängliche Lauf von 8s und 1s ist in nur die linke Hälfte aufgeteilt und die Lauflänge ist nur als die Länge der alternierenden Läufe codiert. Läufe von mehr als 24 werden in Läufe von höchstens 24 aufgeteilt, die durch Läufe von 0 getrennt sind, so dass die Längen mit Basis 25 codiert und dann mit Basis 256 codiert werden können, um sie zu komprimieren.

Peter Taylor
quelle
1

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

Verwendet einen etwas anderen Ansatz für die Antwort von @icrieverytim . -10 Bytes dank @Shaggys Vorschlag, replaceanstelle von 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>

Dom Hastings
quelle
1
287 Bytes .
Shaggy
1

/// 260 Bytes

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

Probieren Sie es online!

Nichts schrecklich Interessantes, nur etwas Komprimierung.

Conor O'Brien
quelle
1

Mathematica, 192 Bytes

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

Siehe: http://reference.wolfram.com/language/ref/Compress.html

Eric Towers
quelle
1

Python 2 , 191 190 188 Bytes

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

Probieren Sie es online!

Gleiches Prinzip wie meine Antwort hier

TFeld
quelle