Uscita PPCG Prime

69

Questo è il PPCG Prime

Lunghezza di 624 cifre

777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777111111111111111111111111111111111111111111111111111111111111111111111111111111188888888118888888811188888811188888811188111118818811111881881111881881111881188111118818811111881881111111881111111188888888118888888811881111111881118888188111111118811111111881111111881111881188111111118811111111881111881881111881188111111118811111111188888811188888811111111111111111111111111111111111111111111111111111111111111111111111111111111333333333333333333333333333333333333333



Se dividiamo ogni 39 cifre otteniamo

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

Il tuo compito è produrre PPCG-Prime

Questo è codegolf. Vince il codice più breve in byte.

Se si inserisce PPCG-Prime nella funzione Mathematica di seguito, si ottiene questo risultato 

ArrayPlot@Partition[IntegerDigits@#,39]&

inserisci qui la descrizione dell'immagine

code-golf  kolmogorov-complexity  primes 
37
Come mai l'hai trovato?
— Stewie Griffin,
5
@StewieGriffin La probabilità media che un numero nsia primo è proporzionale 1/log(n), che comunque non è molto piccola. Basta controllare molti numeri fino a quando non è primo.
— user202729,
2
I commenti non sono per una discussione estesa; questa conversazione è stata spostata in chat .
— Dennis,
1
@ user202729 log(n)è circa 1436.6in questo caso.
— Jeppe Stig Nielsen,
3
@Fabian Non penso che questo metodo sarebbe efficace ... Per un Prime così grande (624 cifre), il numero che stai chiedendo ha 621 cifre (ed è ancora più difficile da golf), A meno che questo non sia il 10 ^ 621 Prime !!! Se vuoi trovare il tuo numero, ecco una semplice approssimazione x/logxdi Gauss

Risposte:

22

Gelatina , 55 54 52 47 46 byte

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

Ci sono approcci più contorti nella storia delle revisioni, ma questo semplice li batte tutti.

Provalo online!

Come funziona

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

Questo è un valore letterale numerico, codificato nella base biiettiva 250, in cui le cifre sono tratte dalla tabella codici di Jelly. L'argomento della catena (a sinistra) e il valore restituito sono impostati
sull'intero codificato, n: = 0x21871c77d7d7af6fafafeff0c37f72ff7fbfbdbfdfef5edfeff8e3 .

“¿mŻ“p’

Un letterale simile a quello sopra, ma il secondo “separa due numeri interi codificati. Il valore restituito viene sostituito con l'array codificato, [777711, 113] .

Dx39

Dconverte il valore restituito in decimale ( [[7, 7, 7, 7, 1, 1], [1, 1, 3]] ), quindi x39ripete ogni singolo numero intero / cifra nel risultato 39 volte. Questo produce una coppia di matrici, che contiene le cifre prima e dopo il testo alto di 7 caratteri, rispettivamente. Chiamiamo questo array A .

jB

Innanzitutto, Bconverte l'argomento (a sinistra) n in binario. Questo produce le cifre che formano il testo alto di 7 caratteri, dove ogni 88 è stato sostituito da 0 .

Quindi, junisce la matrice A , usando la matrice binaria come separatore.

o88

Ciò esegue OR logico con 88 , sostituendo ogni 0 con 88 .

V

Ora abbiamo le cifre corrette, ma in una matrice di 7 ', 1 ', 88 'e 3 '. Vtrasforma implicitamente questo array in una stringa e quindi lo elimina, producendo un unico numero intero.

— Dennis
fonte
6

Bubblegum , 51 byte

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

Provalo online!

— OVS
fonte
6

SOGL V0.12 , 52 51 byte

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

lega gomma da masticare!
nota che questa risposta contiene una scheda

Provalo qui!

Cerca di salvare byte riutilizzando la stessa stringa per entrambi P.

Spiegazione:

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

I numeri lì vengono salvati dall'originale a partire in basso a sinistra, salendo, quindi 1 a destra e in basso, quindi in alto, ecc.

Una versione a compressione normale a 52 byte:

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

Provalo qui!

— dzaima
fonte
Non sono sicuro che quello che hai pubblicato sia il codice corretto ...
— Erik the Outgolfer,
1
come ...‘ottiene quei numeri?
— Pureferret,
1
@Pureferret Compressione stringa.
— totalmente umano il
@totallyhuman quindi come "codifica" / comprime le stringhe ...‘?
— Pureferret,
@dzaima Non penso che mi aiuti a capire, sfortunatamente. L'immissione della prima parte che codifica CGin quello strumento non fornisce alcuna ...‘parte in quello strumento.
— Pureferret,
4

Mathematica, 107 byte

Uncompress@"1:eJxTTMoP8ixgYmAwH8TAkLrAAgqQWYbYGFDVGCxkBh5lCDNwWIqqDCyGrAGDhWEpFmXY3IaiDItPqQqMiQMA+yaAoA=="


Provalo online!

— J42161217
fonte
Correggimi se sbaglio, ma è solo una soluzione REPL? Questa non sembra essere una funzione (che immagino tu possa risolvere con un singolo &alla fine).
— numbermaniac,
questa non dovrebbe essere una funzione. questo codice emette solo il PPCG prime, proprio come richiesto dall'OP
— J42161217,
4

CJam, ASCII, 61

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

Provalo online

Aggiungi ]s39/N*per un bel confezionamento.

Spiegazione:

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
fonte
4

C, 519 427 414 396 377 byte

Grazie a Tas, Felix Palmen e 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)}

Per il tuo interesse, ecco una versione più lunga e più facile da leggere:

#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
fonte
1
Puoi ottenere molto più in basso (~ 450ish) semplicemente stampando gli 1 e gli 8 così come sono e avendo una definizione per il 7, 3 e 1
— Tas
@Keyu Gan: sto compilando una versione corrente di GCC (7.2.0-debian11), che lo consente da un paio d'anni. Non sono del tutto sicuro se la sintassi sia forse in uno dei più recenti standard C.
— xanoetux,
2
@Keyu Gan: è consentito in C99 e C11.
— xanoetux,
1
— Felix Palmen,
Questa versione è molto complicata. Almeno lo capisco; Grazie.
— 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);}

Provalo online!

Crediti

  • -10 byte grazie ad aditsu!
— Olivier Grégoire
fonte
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,
Bella cattura, il doppio 88, grazie!
— Olivier Grégoire,
2

Retina , 129 byte


h155b78i7b1i7b2i5b2i5b2!4!!4!""1!4!!4!!6#i7b1i7b1!6!2i3b##!6"1##""1#!8i5b2i5b79d38
#
!7
"
!3!
!
i1b
\d+
$*
+`(\D)1
$1$1
1

T`l`d

Provalo online!

— OVS
fonte
2

Lotto, 364 335 333 byte

@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
fonte
1
Salvare due byte cambiando echo|incd|
— stevefestl il
Grazie, sapevo che c'era qualcosa di più corto, ma non riuscivo a ricordare
— schnaader,
Inoltre, (1,1,156) dopuò essere abbreviato in(1,1,156)do
— stevefestl il
2

Javascript (ES6), 187 181 byte

-6 byte grazie a @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)

Approccio super semplice; probabilmente potrebbe essere un po 'più golfato.

Spiegazione

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

Esempio di frammento di codice (con un po 'di codice helper per aggiungere interruzioni di linea nell'output)

Mostra snippet di codice

— Herman L
fonte
È possibile salvare alcuni byte se si definisce una funzione di supporto r, come r=s=>s[0].repeat(39)e quindi sostituire a, be kcon r`7` ecc provare on-line! .
— Justin Mariner,
2

C (gcc) , 269 267 byte

funzione, utilizza RLE semplice.

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

Provalo online!

— Felix Palmen
fonte
Suggerisci L"'OP\x9c"invece dix
— ceilingcat il
2

C (gcc) , 224 byte

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

Provalo online!

Contiene alcuni non stampabili, il valore letterale della stringa è "ww\x11dfFdfFDfFDfFDFDDFFDDFFDddDDFdDDddDDddDDDdDDDDffDffDFDDDFDfdDDDDFDDDdDDDdDDFdDDDDFDDDdDDFFDdDFDDDdDDDDdfDdfD\x11\x03".

— Lynn
fonte
1

Gelatina , 86 byte

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

Provalo online!

-12 byte grazie a user202729

— HyperNeutrino
fonte
88 byte: TIO ( “can separates a list of strings inside a string literal)
— user202729
Che ore sono nel vostro Paese? Perché sei sveglio adesso?
— user202729,
@ user202729 Oh giusto, grazie. E sono in UTC-4, ho fatto uno stupido e ho dovuto alzarmi fino a tardi, quindi mi è venuta voglia di fare una sfida prima di andare a dormire, poiché questa è stata riaperta. Posso elaborare in chat se vuoi: P
— HyperNeutrino,
1

Python 2 , 309 158 155 136 135 byte

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

Provalo online!

Python 2 , 137 byte

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

Provalo online!

— TFeld
fonte
1

Gelatina , 85 byte

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

Provalo online!

Basato sull'approccio di Dennis alla sfida della Trinity Hall, meno la simmetria, più le prime 7e le secondarie 3.

— Erik the Outgolfer
fonte
3
Dennis ha affrontato questa sfida in modo diverso perché è diversa. Penso che tu sia stato superato!
@JoseZaman Ha creato Jelly BTW.
— Erik the 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

Provalo online!

Moltiplicazione, concatenazione e sostituzioni di stringhe. PowerShell non ha base 36 o simili, quindi le opzioni di compressione di grandi numeri sono limitate. Potrebbe esserci un modo migliore per "comprimere" la parte centrale - lo sto ancora verificando.

— AdmBorkBork
fonte
1

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

Per prima cosa esporti il ​​numero in un file GZIP. Questo file, denominato "o" senza estensione, sarà esattamente 71 byte, che conta per il totale. Per impostazione predefinita, andrà al tuo $TemporaryDirectory. Omettere cifre per leggibilità.

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

Poi

"o"~Import~"GZIP"

ricostruirà il numero. Il nome del file è un byte, quindi ecco da dove proviene il +1.

Provalo online!

— Kelly Lowder
fonte
1

Rubino, 109 byte

Lo script chiama Zlib.inflateper decomprimere il numero. Ha bisogno almeno di Ruby 1.9.3. Contiene byte non stampabili, quindi non posso incollarlo qui.

Ho incollato l'output di 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-!

Se hai unvis (1), esegui unvis prime-inflate.vis > prime-inflate.rbper ripristinare lo script a 109 byte. Oppure puoi decodificare Base64, di seguito, con ruby -e 'print *STDIN.read.unpack(?m)' < prime-inflate.b64 > prime-inflate.rb.

cmVxdWlyZSd6bGliJwpwdXRzIFpsaWIuaW5mbGF0ZSBEQVRBLnJlYWQKX19F
TkRfXwp42jM3H7zAkLrAAgqQWYbYGFDVGCxkBh5lCDNwWIqqDCyGrAGDhWEp
FmXY3IaiDItPqQqMiQMAEPB+oQ==

Chiamo Zlib.inflatequindi non ho bisogno di progettare e giocare a golf il mio algoritmo di decompressione. Uso DATAcon __END__perché la stringa compressa non è valida UTF-8. Il codice Ruby deve essere valido ASCII (in Ruby 1.9.x) o UTF-8 (da Ruby 2.0) o avere un commento magico #coding:binaryper cambiare la codifica, ma Ruby non controlla la codifica dopo __END__.

— kernigh
fonte
1

6502 codice macchina (C64), 142 122 byte

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

Uso: sys49152

  • -20 byte con una migliore implementazione dello stesso metodo e tabelle di dati anche per blocchi di grandi dimensioni.

Spiegazione

Questo utilizza anche le lunghezze delle sequenze 1e 8nella parte centrale; poiché sono tutti più brevi di 16, due di essi sono codificati per byte.

Elenco di smontaggio commentato:

         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
fonte
1

C (gcc) , 188 187 185 byte

-1 grazie a JonathanFrech.

-2 grazie a 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);}

Provalo online!

— gastropner
fonte
2
Benvenuto in PPCG, bella prima risposta!
— Ovs
Penso che puoi spostare la stringa per arrivare a una stringa che non ha bisogno di sfuggire a una barra rovesciata, con conseguente 187 byte .
— Jonathan Frech,
@JonathanFrech Ah, bello!
— Gastropner
@ceilingcat Buona cattura!
— Gastropner,
0

Befunge-93 , 500 byte

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

Provalo online!

— ItsJ0el
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.