Wyjście PPCG Prime

69

To jest PPCG Prime

624 cyfry

777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777111111111111111111111111111111111111111111111111111111111111111111111111111111188888888118888888811188888811188888811188111118818811111881881111881881111881188111118818811111881881111111881111111188888888118888888811881111111881118888188111111118811111111881111111881111881188111111118811111111881111881881111881188111111118811111111188888811188888811111111111111111111111111111111111111111111111111111111111111111111111111111111333333333333333333333333333333333333333



Jeśli dzielimy co 39 cyfr, otrzymujemy

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

Twoim zadaniem jest wygenerowanie PPCG-Prime

To jest codegolf. Najkrótszy kod w bajtach wygrywa.

Jeśli wprowadzisz PPCG-Prime w poniższej funkcji Mathematica, otrzymasz ten wynik 

ArrayPlot@Partition[IntegerDigits@#,39]&

wprowadź opis zdjęcia tutaj

code-golf  kolmogorov-complexity  primes 
37
Jak do diabła to znalazłeś?
— Stewie Griffin
5
@StewieGriffin Średnie prawdopodobieństwo, że liczba nbędzie liczbą pierwszą, jest proporcjonalne do 1/log(n), co zresztą niezbyt małe. Po prostu sprawdź wiele liczb, aż będzie pierwsza.
— user202729,
2
Komentarze nie są przeznaczone do rozszerzonej dyskusji; ta rozmowa została przeniesiona do czatu .
— Dennis
1
W tym przypadku log(n)chodzi o @ user202729 1436.6.
— Jeppe Stig Nielsen
3
@Fabian Nie sądzę, aby ta metoda była skuteczna ... W przypadku tak dużego Prime'a (624 cyfry) liczba, o którą pytasz, ma 621 cyfr (i jest jeszcze trudniejsza do gry w golfa), chyba że jest to 10 ^ 621. główny!!! Jeśli chcesz znaleźć swój numer, oto proste przybliżenie x/logxGaussa

Odpowiedzi:

22

Galaretka , 55 54 52 47 46 bajtów

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

W historii zmian istnieje bardziej skomplikowane podejście, ale ten prosty pokonuje je wszystkie.

Wypróbuj online!

Jak to działa

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

Jest to literał liczbowy, zakodowany w bazie bijective 250, gdzie cyfry są pobierane ze strony kodowej Jelly. Argument łańcucha (lewy) i wartość zwracana są ustawione na zakodowaną liczbę całkowitą,
n: = 0x21871c77d7d7af6fafafeff0c37f72ff7fbfbdbfdfef5edfeff8e3 .

“¿mŻ“p’

Podobny dosłownie do powyższego, ale drugi “oddziela dwie zakodowane liczby całkowite. Zwracana wartość jest zastępowana zakodowaną tablicą [777711, 113] .

Dx39

Dkonwertuje wartość zwracaną na dziesiętną ( [[7, 7, 7, 7, 1, 1], [1, 1, 3]] ), a następnie x39powtarza każdą liczbę całkowitą / cyfrę w wyniku 39 razy. Daje to parę tablic, które zawierają cyfry odpowiednio przed i po 7-znakowym tekście. Nazwijmy tę tablicę A .

jB

Najpierw Bkonwertuje (lewy) argument n na binarny. Daje to cyfry tworzące 7-znakowy tekst, przy czym każde 88 zostało zastąpione przez 0 .

Następnie jdołącza do tablicy A , używając tablicy binarnej jako separatora.

o88

Wykonuje się z logicznego OR 88 , zastępując każdy 0 do 88 .

V

Mamy teraz prawidłowe cyfry, ale w tablicy 7 , 1 , 88 i 3 . Vniejawnie zamienia tę tablicę w ciąg, a następnie analizuje ją, uzyskując pojedynczą liczbę całkowitą.

— Dennis
źródło
6

Bubblegum , 51 bajtów

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

Wypróbuj online!

— ovs
źródło
6

SOGL V0.12 , 52 51 bajtów

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

więzi gumy do żucia!
zwróć uwagę, że ta odpowiedź zawiera zakładkę

Wypróbuj tutaj!

Próbuje zapisać bajty, ponownie wykorzystując ten sam ciąg znaków dla obu Ps.

Wyjaśnienie:

...‘...‘²Κ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

Liczby tam są zapisywane od oryginału, zaczynając od lewego dolnego rogu, przechodząc w górę, następnie 1 w prawo i w dół, a następnie w górę, itd.

52-bajtowa wersja z kompresją zwykłą:

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

Wypróbuj tutaj!

— dzaima
źródło
Nie jestem pewien, czy to, co napisałeś, jest w ogóle poprawnym kodem ...
— Erik Outgolfer
1
skąd ...‘te liczby?
— Pureferret
1
@ Kompresja stringów Pureferret.
— całkowicie ludzki,
@ totalniehuman, więc w jaki sposób „koduje” / kompresuje te ciągi ...‘?
— Pureferret
@dzaima Nie sądzę, że to pomaga mi niestety zrozumieć. Wprowadzenie pierwszej części, która koduje CGto narzędzie, nie daje żadnego ...‘miejsca w tym narzędziu.
— Pureferret
4

Mathematica, 107 bajtów

Uncompress@"1:eJxTTMoP8ixgYmAwH8TAkLrAAgqQWYbYGFDVGCxkBh5lCDNwWIqqDCyGrAGDhWEpFmXY3IaiDItPqQqMiQMA+yaAoA=="


Wypróbuj online!

— J42161217
źródło
Popraw mnie, jeśli się mylę, ale czy jest to rozwiązanie tylko do REPL? To nie wydaje się być funkcją (którą, jak sądzę, można naprawić za pomocą singla &na końcu).
— numbermaniac
to nie powinna być funkcja. ten kod po prostu generuje liczbę pierwszą PPCG, tak jak poprosił OP
— J42161217,
4

CJam, ASCII, 61

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

Wypróbuj online

Dołącz ]s39/N*do ładnego opakowania.

Wyjaśnienie:

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
źródło
4

C 519 427 414 396 377 bajtów

Dzięki Tas, Felix Palmen i 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)}

Dla twojego zainteresowania, oto dłuższa, łatwiejsza do odczytania wersja:

#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
źródło
1
Możesz uzyskać znacznie niższą wartość (~ 450ish), po prostu wypisując jedynki i ósme tak, jak są, i mając definicję dla 7, 3 i 1
— Tas
@Keyu Gan: Kompiluję się z aktualną wersją GCC (7.2.0-debian11), która pozwala na to przez kilka lat. Nie jestem całkiem pewien, czy składnia może być w jednym z nowszych standardów C.
— xanoetux
2
@Keyu Gan: Jest to dozwolone w C99 i C11.
— xanoetux
1
— Felix Palmen
Ta wersja jest bardzo trudna. Przynajmniej ja to rozumiem; dzięki.
— xanoetux
4

Java (OpenJDK 8) , 165 bajtów

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

Wypróbuj online!

Kredyty

  • -10 bajtów dzięki aditsu!
— Olivier Grégoire
źródło
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
Niezły chwyt, podwójny 88, dzięki!
— Olivier Grégoire,
2

Partia, 364 335 333 bajtów

@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
źródło
1
Zaoszczędź dwa bajty, zmieniając echo|nacd|
— stevefestl
Dzięki, wiedziałem, że było coś krótszego, ale nie mogłem sobie przypomnieć
— schnaader
Można także (1,1,156) doskrócić do(1,1,156)do
— stevefestl
2

JavaScript (ES6), 187 181 bajtów

-6 bajtów dzięki @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 proste podejście; prawdopodobnie można by jeszcze trochę zagrać w golfa.

Wyjaśnienie

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

Przykładowy fragment kodu (z pewnym kodem pomocniczym do dodania podziału wiersza na wyjściu)

Pokaż fragment kodu

— Herman L.
źródło
Można zaoszczędzić kilka bajtów, jeśli zdefiniować funkcję pomocnika r, jak r=s=>s[0].repeat(39)i wtedy wymienić a, boraz kz r`7` itp Wypróbuj online! .
— Justin Mariner
2

C (gcc) , 269 267 bajtów

funkcja wykorzystuje prosty 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);}

Wypróbuj online!

— Felix Palmen
źródło
Zaproponuj L"'OP\x9c"zamiastx
— ceilingcat
2

C (gcc) , 224 bajty

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

Wypróbuj online!

Zawiera pewne niedrukowalne, literał ciąg jest "ww\x11dfFdfFDfFDfFDFDDFFDDFFDddDDFdDDddDDddDDDdDDDDffDffDFDDDFDfdDDDDFDDDdDDDdDDFdDDDDFDDDdDDFFDdDFDDDdDDDDdfDdfD\x11\x03".

— Lynn
źródło
1

Galaretka , 86 bajtów

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¤Ḍ

Wypróbuj online!

-12 bajtów dzięki user202729

— HyperNeutrino
źródło
88 bajtów: TIO ( “puszka separates a list of strings inside a string literal)
— 202729
Która jest godzina w twoim kraju? Dlaczego nie śpisz?
— user202729,
@ user202729 Och, dzięki. A ja jestem na UTC-4, zrobiłem głupka i musiałem spać późno, więc miałem ochotę podjąć wyzwanie przed pójściem spać, odkąd to się otworzyło. Mogę opracować na czacie, jeśli chcesz: P
— HyperNeutrino
1

Python 2 , 309 158 155 136 135 135 bajtów

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

Wypróbuj online!

Python 2 , 137 bajtów

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

Wypróbuj online!

— TFeld
źródło
1

Galaretka , 85 bajtów

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

Wypróbuj online!

Oparte na podejściu Dennisa do wyzwania Trinity Hall, minus symetria, plus 7s wiodące i końcowe 3s.

— Erik the Outgolfer
źródło
3
Dennis podszedł do tego wyzwania inaczej, ponieważ jest ono inne. Myślę, że zostałeś obezwładniony!
@JoseZaman Zrobił Jelly BTW.
— Erik the Outgolfer
1

PowerShell , 164 bajty

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

Wypróbuj online!

Mnożenie, łączenie i zamienianie ciągów. PowerShell nie ma bazy 36 lub podobnej, więc opcje kompresji dużej liczby są ograniczone. Może być lepszy sposób na „skompresowanie” środkowej części - wciąż to sprawdzam.

— AdmBorkBork
źródło
1

Wolfram Language (Mathematica) , 89 (17 + 71 + 1) bajtów

Najpierw wyeksportuj numer do pliku GZIP. Plik o nazwie „o” bez rozszerzenia będzie miał dokładnie 71 bajtów, co wlicza się do sumy całkowitej. Domyślnie trafi do twojego $TemporaryDirectory. Pominięcie cyfr dla czytelności.

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

Następnie

"o"~Import~"GZIP"

zrekonstruuje liczbę. Nazwa pliku to jeden bajt, stąd pochodzi +1.

Wypróbuj online!

— Kelly Lowder
źródło
1

Rubin, 109 bajtów

Skrypt wywołuje Zlib.inflatedekompresję numeru. Potrzebuje co najmniej Ruby 1.9.3. Zawiera niezadrukowane bajty, więc nie mogę go tutaj wkleić.

Wklejam wynik 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-!

Jeśli masz unvis (1), uruchom, unvis prime-inflate.vis > prime-inflate.rbaby przywrócić 109-bajtowy skrypt. Lub możesz zdekodować Base64 poniżej za pomocą ruby -e 'print *STDIN.read.unpack(?m)' < prime-inflate.b64 > prime-inflate.rb.

cmVxdWlyZSd6bGliJwpwdXRzIFpsaWIuaW5mbGF0ZSBEQVRBLnJlYWQKX19F
TkRfXwp42jM3H7zAkLrAAgqQWYbYGFDVGCxkBh5lCDNwWIqqDCyGrAGDhWEp
FmXY3IaiDItPqQqMiQMAEPB+oQ==

Dzwonię, Zlib.inflatewięc nie muszę projektować i wykorzystywać własnego algorytmu dekompresyjnego. Używam DATAz, __END__ponieważ skompresowany ciąg nie jest prawidłowy UTF-8. Kod Ruby musi być poprawny ASCII (w Ruby 1.9.x) lub UTF-8 (z Ruby 2.0) lub mieć magiczny komentarz, #coding:binaryaby zmienić kodowanie, ale Ruby nie sprawdza kodowania później __END__.

— kernigh
źródło
1

Kod maszynowy 6502 (C64), 142 122 bajty

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

Demo online

Stosowanie: sys49152

  • -20 bajtów z lepszą implementacją tej samej metody i tabel danych również dla dużych bloków.

Wyjaśnienie

To również używa długości 1i 8sekwencji w środkowej części; ponieważ wszystkie mają mniej niż 16, dwa z nich są kodowane na bajt.

Skomentowany wykaz deasemblacji:

         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
źródło
1

C (gcc) , 188 187 185 bajtów

-1 dzięki JonathanFrech.

-2 dzięki pułapkowi cat.

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

Wypróbuj online!

— gastropner
źródło
2
Witamy w PPCG, fajna pierwsza odpowiedź!
— ovs
Myślę, że możesz przesunąć swój ciąg, aby uzyskać ciąg, który nie wymaga ucieczki przed odwrotnym ukośnikiem, co daje 187 bajtów .
— Jonathan Frech,
@JathanathanFrech Ach, miło!
— gastropner
@ceilingcat Good catch!
— gastropner
0

Befunge-93 , 500 bajtów

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

Wypróbuj online!

— ItsJ0el
ź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.