Ausgabe des PPCG Prime

69

Dies ist der PPCG Prime

624 Ziffern lang

777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777111111111111111111111111111111111111111111111111111111111111111111111111111111188888888118888888811188888811188888811188111118818811111881881111881881111881188111118818811111881881111111881111111188888888118888888811881111111881118888188111111118811111111881111111881111881188111111118811111111881111881881111881188111111118811111111188888811188888811111111111111111111111111111111111111111111111111111111111111111111111111111111333333333333333333333333333333333333333



Wenn wir alle 39 Stellen teilen, erhalten wir

777777777777777777777777777777777777777
777777777777777777777777777777777777777
777777777777777777777777777777777777777
777777777777777777777777777777777777777
111111111111111111111111111111111111111
111111111111111111111111111111111111111
188888888118888888811188888811188888811
188111118818811111881881111881881111881
188111118818811111881881111111881111111
188888888118888888811881111111881118888
188111111118811111111881111111881111881
188111111118811111111881111881881111881
188111111118811111111188888811188888811
111111111111111111111111111111111111111
111111111111111111111111111111111111111
333333333333333333333333333333333333333

Ihre Aufgabe ist es, das PPCG-Prime auszugeben

Dies ist Codegolf. Der kürzeste Code in Bytes gewinnt.

Wenn Sie das PPCG-Prime in die folgende Mathematica-Funktion eingeben, erhalten Sie dieses Ergebnis 

ArrayPlot@Partition[IntegerDigits@#,39]&

Bildbeschreibung hier eingeben

code-golf  kolmogorov-complexity  primes 
37
Wie um alles in der Welt haben Sie das gefunden?
— Stewie Griffin
5
@StewieGriffin Die durchschnittliche Wahrscheinlichkeit, dass eine Zahl neine Primzahl ist 1/log(n), ist proportional zu , was ohnehin nicht sehr gering ist. Überprüfen Sie einfach viele Zahlen, bis es Primzahl ist.
— User202729
2
Kommentare sind nicht für längere Diskussionen gedacht. Diese Unterhaltung wurde in den Chat verschoben .
— Dennis
1
@ user202729 log(n)ist 1436.6in diesem Fall ungefähr .
— Jeppe Stig Nielsen
3
@ Fabian Ich glaube nicht, dass diese Methode effizient wäre ... Für einen Prime mit dieser Größe (624 Stellen) hat die von Ihnen angeforderte Zahl 621 Stellen (und ist noch schwieriger zu golfen), es sei denn, dies ist die 10 ^ 621 prime !!! Wenn Sie Ihre Nummer finden möchten, finden Sie hier eine einfache Annäherung x/logxvon Gauss

Antworten:

22

Jelly , 55 54 52 47 46 Bytes

“=÷¡v⁺ʋiṂYR¤"bİɲ}Ñ1Ṇ⁴ẠV⁹yȥGẇ’“¿mŻ“p’Dx39jBo88V

Es gibt mehr verschlungene Ansätze in der Revisionshistorie, aber diese einfache übertrifft sie alle.

Probieren Sie es online!

Wie es funktioniert

“=÷¡v⁺ʋiṂYR¤"bİɲ}Ñ1Ṇ⁴ẠV⁹yȥGẇ’

Dies ist ein numerisches Literal, das in der bijektiven Basis 250 codiert ist, wobei die Ziffern aus Jellys Codepage entnommen sind. Das (linke) Argument der Kette und der Rückgabewert werden auf die codierte Ganzzahl gesetzt,
n: = 0x21871c77d7d7af6fafafeff0c37f72ff7fbfbdbfdfef5edfeff8e3 .

“¿mŻ“p’

Ein ähnliches Wort wie das obige, aber das zweite “trennt zwei codierte ganze Zahlen. Der Rückgabewert wird durch das codierte Array [777711, 113] ersetzt .

Dx39

Dkonvertiert den Rückgabewert in eine Dezimalzahl ( [[7, 7, 7, 7, 1, 1], [1, 1, 3]] ) und x39wiederholt dann jede einzelne Ganzzahl / Ziffer im Ergebnis 39 Mal. Dies ergibt ein Array-Paar, das die Ziffern vor und nach dem 7-stelligen Hochtext enthält. Lassen Sie uns dieses Array nennen A .

jB

Zuerst Bwandelt die (linke) Argument n binär. Dies ergibt die Ziffern, die den 7-stelligen Hochtext bilden, wobei jede 88 durch 0 ersetzt wurde .

Dann jschließt sich die Matrix A , die binäre Array als Separator verwendet wird .

o88

Dies führt ein logisches ODER durch 88 aus und ersetzt jede 0 durch 88 .

V

Wir haben jetzt die richtigen Ziffern, aber in einem Array von 7 , 1 , 88 und 3 . VVerwandelt dieses Array implizit in einen String und wertet ihn dann aus, wobei eine einzelne Ganzzahl erhalten wird.

— Dennis
quelle
6

Bubblegum , 51 Bytes

00000000: 331f c4c0 90ba c002 0a90 5986 d818 50d5  3.........Y...P.
00000010: 282c 3406 6e65 5036 1e4b 9195 8109 649d  (,4.neP6.K....d.
00000020: 5858 1896 4279 68b2 f895 61fa 94ca c098  XX..Byh...a.....
00000030: 3800 00                                  8..

Probieren Sie es online!

— ovs
quelle
6

SOGL V0.12 , 52 51 Bytes

≡=vā⁷H↕↕jΥ_Ν↑∆∫▲pΖo	‘θδžΟwd╬2n?q[‘²Κ7n⌡"α¼■╤ģ⅞¹‘¹H∑

krawatten bubblegum!
Beachten Sie, dass diese Antwort eine Registerkarte enthält

Probieren Sie es hier aus!

Versucht, Bytes zu speichern, indem dieselbe Zeichenfolge für beide Ps wiederverwendet wird .

Erläuterung:

...‘...‘²Κ7n⌡"..‘¹H∑  compressed strings replaced with ellipses to shorten the width
...‘                  pushes "1111111188888188888888111118811111881111188111118881118818111811111111188888188888888111118811111881111188118118888818818881811118111" - CG
    ...‘              pushes "1111111888888888888881118118111811811181181118118111811811188881111881" - P
        ²             join with itself - double the P
         Κ            reverse add - prepend the PP to CG
          7n          split to line lengths of 7
            ⌡         for each
             "..‘       push "311ŗ117777" with ŗ replaced with the ToS - current item looping over
                 ¹    wrap the results tn an array
                  H   rotate it counter-clockwise
                   ∑  join to a single string

Die Nummern dort werden ab dem Original gespeichert, beginnend links unten, aufwärts, dann 1 rechts und abwärts, dann aufwärts, ect.

Eine 52-Byte-Version mit einfacher Komprimierung:

#⅓→9E■Ν►1&⅝θ⅞%øøμ←N═]y)u⅝↓$A○░(ZF16Φ⅓Mč▓d⅛Hι‼∑υnη▲Z‘

Probieren Sie es hier aus!

— dzaima
quelle
Ich bin mir nicht sicher, ob das, was Sie gepostet haben, überhaupt der richtige Code ist ...
— Erik the Outgolfer
1
Wie kommt ...‘man an diese Zahlen?
— Pureferret
1
@ Pureferret String-Komprimierung.
— Totalhuman
@totallyhuman Also, wie wird diese Zeichenfolge "codiert" / komprimiert ...‘?
— Pureferret
@dzaima Ich glaube das hilft mir eigentlich leider nicht zu verstehen. Wenn Sie den ersten Teil eingeben, der das CGin dieses Werkzeug codiert, wird in diesem Werkzeug nichts ...‘angezeigt.
— Pureferret
4

Mathematica, 107 Bytes

Uncompress@"1:eJxTTMoP8ixgYmAwH8TAkLrAAgqQWYbYGFDVGCxkBh5lCDNwWIqqDCyGrAGDhWEpFmXY3IaiDItPqQqMiQMA+yaAoA=="


Probieren Sie es online!

— J42161217
quelle
Korrigieren Sie mich, wenn ich falsch liege, aber ist das nur eine REPL-Lösung? Das scheint keine Funktion zu sein (was Sie vermutlich mit einer einzigen &am Ende beheben könnten ).
— Numbermaniac
das soll keine funktion sein. Dieser Code gibt nur die PPCG-Primzahl aus, so wie es das OP verlangt hat
— J42161217
4

CJam, ASCII, 61

Hs78f*~_@"'hfv;HH`>O4RU(_o^.U)9q&-1iadr`4tk"90b2b88fe|1$'339*

Probieren Sie es online aus

Fügen Sie ]s39/N*für schöne Verpackung.

Erläuterung:

Hs         generate "17" (H=17)
78f*       repeat each character 78 times, getting an array of 2 strings
~_         dump the 2 strings on the stack, and duplicate the '7's
@          move the '1's to the top of the stack (first 6 lines done so far)
"…"90b     convert that string from base 90 (treating characters as numbers)
2b         convert the resulting number to base 2,
            obtaining a bit map for the "PPCG" part, with 1 for "1" and 0 for "88"
88fe|      replace (boolean OR) all the zeros with 88
1$         copy the string of 78 '1's
'339*      repeat '3' 39 times
— aditsu
quelle
4

C, 519 427 414 396 377 Bytes

Vielen Dank an Tas, Felix Palmen und Lynn.

#define p(n,l)for(i=40*l;i;)putchar(--i%40?n+48:10);
f(i){p(7,4)p(1,2)puts("188888888118888888811188888811188888811\n188111118818811111881881111881881111881\n188111118818811111881881111111881111111\n188888888118888888811881111111881118888\n188111111118811111111881111111881111881\n188111111118811111111881111881881111881\n188111111118811111111188888811188888811");p(1,2)p(3,1)}

Für Ihr Interesse ist hier eine längere, besser lesbare Version:

#define p(n,l) for(i=40*l;i;) putchar(--i%40?n+48:10);
f(i) {
    p(7,4)
    p(1,2)
    puts("188888888118888888811188888811188888811\n\
       188111118818811111881881111881881111881\n\
       188111118818811111881881111111881111111\n\
       188888888118888888811881111111881118888\n\
       188111111118811111111881111111881111881\n\
       188111111118811111111881111881881111881\n\
       188111111118811111111188888811188888811");
    p(1,2)
    p(3,1)
}
— Xanoetux
quelle
1
Sie können viel niedriger (~ 450ish) werden, indem Sie einfach die 1s und 8s drucken, wie sie sind, und eine Definition für die 7, 3 und 1 haben
— Tas
@Keyu Gan: Ich kompiliere mit einer aktuellen Version von GCC (7.2.0-debian11), die dies für ein paar Jahre ermöglicht. Ich bin nicht ganz sicher, ob die Syntax möglicherweise einem der neueren C-Standards entspricht.
— Xanoetux
2
@Keyu Gan: Es ist in C99 und C11 erlaubt.
— Xanoetux
1
— Felix Palmen
Diese Version ist sehr knifflig. Zumindest verstehe ich es; Vielen Dank.
— Xanoetux
4

Java (OpenJDK 8) , 165 Byte

n->{for(int i=0;++i<566;)System.out.print(i<157?7:i>526?3:i<236|i>446||new java.math.BigInteger("vnku5g6l0zenpa1kydel5rxw162k4fk4xapa154o",36).testBit(446-i)?1:88);}

Probieren Sie es online!

Credits

  • -10 bytes dank aditsu!
— Olivier Grégoire
quelle
165:n->{for(int i=0;++i<566;)System.out.print(i<157?7:i>526?3:i<236|i>446||new java.math.BigInteger("vnku5g6l0zenpa1kydel5rxw162k4fk4xapa154o",36).testBit(446-i)?1:88);}
— aditsu
Netter Fang, das Doppelte 88, danke!
— Olivier Grégoire
2

Batch, 364 335 333 Bytes

@set a=888888&set b=1111111111111&set e=1881111&set d=1%e%&set f=333333333&for /L %%x in (1,1,156) do @cd|set/p=7
@echo %b%%b%%b%%b%%b%%b%1%a%8811%a%88111%a%111%a%1%d%188%e%188%e%88%e%88%d%188%e%188%e%1%d%1111%a%8811%a%88%d%111881118888%e%11%d%11%d%1%d%88%d%11%d%11%d%88%e%88%d%11%d%11111%a%111%a%%b%%b%%b%%b%%b%%b%11%f%%f%%f%%f%333
— schnaader
quelle
1
Speichern Sie zwei Bytes, indem Sie echo|zucd|
— stevefestl
Danke, ich wusste, dass es etwas kürzeres gibt, konnte mich aber nicht erinnern
— schnaader
Auch (1,1,156) dokann verkürzt(1,1,156)do
— stevefestl
2

Javascript (ES6), 187 181 Bytes

-6 Bytes dank @JustinMariner

r=s=>s[0].repeat(39),a=r`7`,b=r`1`,i="8888881",c=188+i,d=11+i,j="188111",e=j+1188,f=j+188,g=j+111,h=g+1,k=r`3`
z=>"aaaabbccdd1eeff1eeghccgj8888hhgf1hhff1hhdd1bbk".replace(/./g,eval)

Super einfacher Ansatz; es könnte wahrscheinlich noch etwas mehr golfen werden.

Erläuterung

r=s=>s[0].repeat(39),                               // helper function to repeat character
a=r`7`,b=r`1`,i="8888881",c=188+i,d=11+i,j="188111",// Set the variables (a-k) to different
e=j+1188,f=j+188,g=j+111,h=g+1,k=r`3`               // parts of the prime       

_=>"aaaabbccdd1eeff1eeghccgj8888hhgf1hhff1hhdd1bbk" // Replace all letters in the string
    .replace(/./g,eval)                             // with the value of the variable

Beispielcode-Snippet (mit etwas Hilfscode zum Hinzufügen von Zeilenumbrüchen in der Ausgabe)

Code-Snippet anzeigen

— Herman L
quelle
Sie können einige Bytes speichern , wenn Sie eine Hilfsfunktion definieren , rwie r=s=>s[0].repeat(39)und dann ersetzen a, bund kmit r`7` usw. Probieren Sie es online! .
— Justin Mariner
2

C (gcc) , 269 267 Bytes

Funktion verwendet einfache RLE.

x[]={39,79,80,156};k;f(i){for(char*c="d7b1882188316831683128512811285128112841281128412821285128112851281128712881882188212871283148112881288128712841282128812881284128112841282128812891683168c1a3";i=*c++;++c)for(i=i<97?i-48:x[i-97];i--;++k%39||puts(""))putchar(*c);}

Probieren Sie es online!

— Felix Palmen
quelle
Schlagen Sie L"'OP\x9c"stattdessen vorx
— ceilingcat
2

C (gcc) , 224 Bytes

f(i,j,c){for(i=0;c="wwdfFdfFDfFDfFDFDDFFDDFFDddDDFdDDddDDddDDDdDDDDffDffDFDDDFDfdDDDDFDDDdDDDdDDFdDDDDFDDDdDDFFDdDFDDDdDDDDdfDdfD"[i/2]>>i++%2*4&15;c-6?putchar(c-4?c+48:49):printf("88"))for(j=0;j++<c%2*38;)putchar(c+48);}

Probieren Sie es online!

Enthält einige nicht druckbare Elemente, das String-Literal lautet "ww\x11dfFdfFDfFDfFDFDDFFDDFFDddDDFdDDddDDddDDDdDDDDffDffDFDDDFDfdDDDDFDDDdDDDdDDFdDDDDFDDDdDDFFDdDFDDDdDDDDdfDdfD\x11\x03".

— Lynn
quelle
1

Jelly , 86 Bytes

Lẋ@1,8żḣLẋ/€F
7ẋ156;1ẋ78¤©;“½Ẹ^o“2FẒ⁶ġbȥ“¡E⁷£cṿ“t¡ɗḋ“£F¢Xȥ“¡McṾbȥ“¬3Ṭo’DÇ€F¤;®;3rẋ39¤Ḍ

Probieren Sie es online!

-12 Bytes dank user202729

— HyperNeutrino
quelle
88 Bytes: TIO ( “can separates a list of strings inside a string literal)
— user202729
Wie spät ist es in Ihrem Land? Warum bist du gerade wach?
— User202729
@ user202729 Ach ja, danke. Und ich bin in UTC-4. Ich war dumm und musste lange aufbleiben, also hatte ich Lust, vor dem Einschlafen eine Herausforderung zu stellen, da diese wieder geöffnet wurde. Ich kann im Chat
— näher darauf eingehen,
1

Python 2 , 309 158 155 136 135 Bytes

x='1'*78
s='7'*156+x
a=1
for c in str(int('109PDKEZ3U32K97KJQVELW8GKXCD42EGEYK715B6HPMPL0H8RU',36)):s+=`a`*int(c);a^=9
print s+x+'3'*39

Probieren Sie es online!

Python 2 , 137 Bytes

s='7'*156
a=1
for c in'90'*8+str(int('PL6PU5TXIC24LCKIQY50C2LPAIC9TVZEVQGTMM63IHGBBUV1XSA6',36))+'09'*8:s+=`a`*int(c);a^=9
print s+'3'*39

Probieren Sie es online!

— TFeld
quelle
1

Jelly , 85 Bytes

”7ẋ“ɓ’80“¡Ȯ⁶LÑɓĠ⁶-€Øġ°$¤ṛọḳƓƒṭ⁽@^ḥ⁷Ofạ<e½Ṇż;,RṘ¶ṀḊ+`⁸ⱮḃĿþṛ9.wƑ¡kḟUẎgLLµ’ḃĖŒṙị⁾1839”3ẋ

Probieren Sie es online!

Basierend auf Dennis 'Herangehensweise an die Trinity Hall-Herausforderung, abzüglich der Symmetrie sowie der führenden 7und nachfolgenden 3.

— Erik der Outgolfer
quelle
3
Dennis ging diese Herausforderung anders an, weil es eine andere ist. Ich glaube, du wurdest überfordert!
@ JoseZaman Er machte Jelly BTW.
— Erik der Outgolfer
1

PowerShell , 164 Byte

$a='136361616151315131531532513151315215436365213213315454521532545453153254541616';6..2|%{$a=$a-replace$_,(11,88,22,34,3332)[$_-2]};'7'*156+'1'*78+$a+'1'*78+'3'*39

Probieren Sie es online!

String-Multiplikation, Verkettung und Ersetzungen. PowerShell verfügt nicht über Base 36 oder ähnliches, daher sind die Komprimierungsoptionen für große Zahlen begrenzt. Es könnte einen besseren Weg geben, den Mittelteil zu "komprimieren" - ich überprüfe das immer noch.

— AdmBorkBork
quelle
1

Wolfram Language (Mathematica) , 89 (17 + 71 + 1) Bytes

Zuerst exportieren Sie die Nummer in eine GZIP-Datei. Diese Datei mit dem Namen "o" ohne Erweiterung hat genau 71 Byte, was für die Gesamtsumme zählt. Standardmäßig geht es zu Ihrem $TemporaryDirectory. Weglassen von Ziffern zur besseren Lesbarkeit.

Export["o",777777...,"GZIP"]

Dann

"o"~Import~"GZIP"

wird die Zahl rekonstruieren. Der Dateiname ist ein Byte, daher kommt die +1 von dort.

Probieren Sie es online!

— Kelly Lowder
quelle
1

Ruby, 109 Bytes

Das Skript ruft Zlib.inflateauf, um die Nummer zu dekomprimieren. Es benötigt mindestens Ruby 1.9.3. Es enthält nicht druckbare Bytes, daher kann ich es hier nicht einfügen.

Ich füge die Ausgabe von vis prime-inflate.rb:

require'zlib'
puts Zlib.inflate DATA.read
__END__
x\M-Z37\^_\M-<\M-@\M^P\M-:\M-@\^B
\M^PY\M^F\M-X\^XP\M-U\^X,d\^F\^^e\^H3pX\M^J\M-*\^L,\M^F\M-,\^A\M^C\M^Ea)\^Ve\M-X\M-\\M^F\M-"\^L\M^KO\M-)
\M^L\M^I\^C\^@\^P\M-p~\M-!

Wenn Sie unvis (1) haben, führen Sie den Befehl aus unvis prime-inflate.vis > prime-inflate.rb, um das 109-Byte-Skript wiederherzustellen. Oder Sie können die Base64 unten mit dekodieren ruby -e 'print *STDIN.read.unpack(?m)' < prime-inflate.b64 > prime-inflate.rb.

cmVxdWlyZSd6bGliJwpwdXRzIFpsaWIuaW5mbGF0ZSBEQVRBLnJlYWQKX19F
TkRfXwp42jM3H7zAkLrAAgqQWYbYGFDVGCxkBh5lCDNwWIqqDCyGrAGDhWEp
FmXY3IaiDItPqQqMiQMAEPB+oQ==

Ich benenne, Zlib.inflatealso muss ich nicht meinen eigenen Dekompressionsalgorithmus entwerfen und Golf spielen. Ich benutze DATAmit, __END__weil die komprimierte Zeichenfolge nicht UTF-8 gültig ist. Ruby-Code muss gültiges ASCII (in Ruby 1.9.x) oder UTF-8 (in Ruby 2.0) sein oder über einen magischen Kommentar verfügen #coding:binary, um die Codierung zu ändern. Ruby überprüft die Codierung jedoch nicht nach __END__.

— Kernigh
quelle
1

6502 Maschinencode (C64), 142 122 Bytes

00 C0 A9 27 85 FB A2 00 86 FC A2 04 CA 10 01 60 BC 70 C0 BD 74 C0 20 D2 FF C6
FB D0 0B 48 A9 27 85 FB A9 0D 20 D2 FF 68 88 D0 EB E0 02 D0 DD 48 A5 FC 4A A8
B9 4A C0 90 04 4A 4A 4A 4A 29 0F F0 08 E6 FC A8 68 49 09 D0 CD 68 D0 C0 28 38
36 36 52 12 52 12 42 12 42 22 52 12 52 12 72 82 28 28 72 32 14 82 82 72 42 22
82 82 42 12 42 22 82 92 36 06 27 50 4F 9C 33 31 31 37

Online-Demo

Verwendungszweck: sys49152

  • -20 Bytes bei besserer Implementierung der gleichen Methode und Datentabellen auch für große Blöcke.

Erläuterung

Dabei werden auch die Längen der 1und 8Sequenzen im Mittelteil verwendet; Da sie alle kürzer als 16 sind, werden zwei von ihnen pro Byte codiert.

Kommentierte Zerlegungsliste:

         00 C0        .WORD $C000       ; load address
.C:c000  A9 27        LDA #$27          ; counter for newlines (39)
.C:c002  85 FB        STA $FB
.C:c004  A2 00        LDX #$00          ; index for run-length data
.C:c006  86 FC        STX $FC
.C:c008  A2 04        LDX #$04          ; index for "blocks" (counting down)
.C:c00a   .blockloop:
.C:c00a  CA           DEX
.C:c00b  10 01        BPL .continue     ; block index underflow -> done
.C:c00d  60           RTS
.C:c00e   .continue:
.C:c00e  BC 70 C0     LDY .lseqlens,X   ; load length of next block to Y
.C:c011  BD 74 C0     LDA .chars,X      ; load character of next block to A
.C:c014   .outloop:
.C:c014  20 D2 FF     JSR $FFD2         ; output character
.C:c017  C6 FB        DEC $FB           ; decrement newline counter
.C:c019  D0 0B        BNE .skipnl
.C:c01b  48           PHA               ; newline needed -> save accu
.C:c01c  A9 27        LDA #$27          ; restore newline counter
.C:c01e  85 FB        STA $FB
.C:c020  A9 0D        LDA #$0D          ; load newline character
.C:c022  20 D2 FF     JSR $FFD2         ; output character
.C:c025  68           PLA               ; restore accu
.C:c026   .skipnl:
.C:c026  88           DEY               ; decrement repeat counter
.C:c027  D0 EB        BNE .outloop      ; repeat until 0
.C:c029  E0 02        CPX #$02          ; check for block index of text part
.C:c02b  D0 DD        BNE .blockloop    ; not in text part -> repeat
.C:c02d   .textpart:
.C:c02d  48           PHA               ; save accu
.C:c02e  A5 FC        LDA $FC           ; load index for run-length data
.C:c030  4A           LSR A             ; and shift right
.C:c031  A8           TAY               ; -> to Y register
.C:c032  B9 4A C0     LDA .seqlens,Y    ; load run-length data
.C:c035  90 04        BCC .lownibble    ; carry clear from shift -> low nibble
.C:c037  4A           LSR A             ; shift high nibble into low nibble
.C:c038  4A           LSR A
.C:c039  4A           LSR A
.C:c03a  4A           LSR A
.C:c03b   .lownibble:
.C:c03b  29 0F        AND #$0F          ; mask low nibble
.C:c03d  F0 08        BEQ .textdone     ; run-length zero? then text block done
.C:c03f  E6 FC        INC $FC           ; increment index for run-length data
.C:c041  A8           TAY               ; run-length to y-register
.C:c042  68           PLA               ; restore accu
.C:c043  49 09        EOR #$09          ; toggle between '8' and '1'
.C:c045  D0 CD        BNE .outloop      ; and back to output loop
.C:c047   .textdone:
.C:c047  68           PLA               ; restore accu
.C:c048  D0 C0        BNE .blockloop    ; back to loop for next block
.C:c04a   .seqlens:
.C:c04a  28 38 36 36  .BYTE $28,$38,$36,$36
.C:c04e  52 12 52 12  .BYTE $52,$12,$52,$12
.C:c052  42 12 42 22  .BYTE $42,$12,$42,$22
.C:c056  52 12 52 12  .BYTE $52,$12,$52,$12
.C:c05a  72 82 28 28  .BYTE $52,$82,$28,$28
.C:c05e  72 32 14 82  .BYTE $72,$32,$14,$82
.C:c062  82 72 42 22  .BYTE $82,$72,$42,$22
.C:c066  82 82 42 12  .BYTE $82,$82,$42,$12
.C:c06a  42 22 82 92  .BYTE $42,$22,$82,$92
.C:c06e  36 06        .BYTE $36,$06
.C:c070   .lseqlens:
.C:c070  27 50 4F 9C  .BYTE $27,$50,$4F,$9C
.C:c074   .chars:
.C:c074  33 31 31 37  .BYTE "3117"
— Felix Palmen
quelle
1

C (GCC) , 188 187 185 Bytes

-1 Danke an JonathanFrech.

-2 dank ceilingcat.

#define F(c,n)for(c=0;c<n;c++)
i,j,k;r(d,n){F(k,n)printf("%d",d);}f(){r(7,156);r(1,79);F(i,45)F(j,6)r("pdpi8pIa7]R>=4gQ>Q2iPoX2=O4a1=QRJ17QR>=4a1i8p"[i]-49>>j&1?8:1,1);r(1,80);r(3,39);}

Probieren Sie es online!

— Gastropner
quelle
2
Willkommen bei PPCG, schöne erste Antwort!
— Ovs
Ich denke, Sie können Ihre Zeichenfolge verschieben, um zu einer Zeichenfolge zu gelangen, die keinen umgekehrten Schrägstrich benötigt, was 187 Bytes ergibt .
— Jonathan Frech
@ JonathanFrech Ah, schön!
— Gastropner
@ceilingcat Guter Fang!
— Gastropner
0

Befunge-93 , 500 Bytes

v F         >20g1-20p
>"3"20g10g`#^_>52*"F"20p30g10g`#v_"^!1"21p30p84*2+1p
^                       p03-1g03<
^>"81118888888811888888881>!"30p84*2+1p52*
^^"8888811188888811"*25"188111118"<>">#7"21p30p57*5p
>*"188111188188111188188111118818"^ $>:#,_@
^25"18811111881881111188188111111"<
>"8888811888888881"25*"1111111881"^
^"88811881111111881118888"*25"188"<
>"1188111111188111111118811111111"^
^"11881"*52"188111111118811111111"<
>"11111881"52*"188111188188111188"^
^"1118811111111188888811188888811"<

Probieren Sie es online!

— ItsJ0el
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.