Disegniamo alcune bombe Atari ST!

46

introduzione

L' Atari ST era un personal computer piuttosto popolare dalla metà degli anni '80 ai primi anni '90, alimentato da un microprocessore Motorola 68000. Su questa macchina, il comportamento predefinito del sistema operativo per le eccezioni della CPU non rilevate era la visualizzazione di una fila di bombe sullo schermo, come mostrato nella figura seguente:

fila di bombe

Fonte: https://commons.wikimedia.org/wiki/File:Row_of_bombs.png
NB: a seconda della versione del sistema operativo, la grafica della bomba può variare leggermente. Ma prendiamo questo come riferimento.

Il numero di bombe dipende dal vettore delle eccezioni, le più comuni sono:

  • ($ 008) Errore bus: 2 bombe
  • ($ 00c) Errore indirizzo: 3 bombe
  • ($ 010) Istruzione illegale: 4 bombe

Obbiettivo

Il tuo obiettivo è quello di scrivere un programma o una funzione che stampi o produca un'arte ASCII di tali bombe Atari ST.

Ingresso

Un numero intero che rappresenta il numero di bombe da visualizzare. Il codice deve supportare i valori più comuni: 2, 3 e 4. Il supporto di meno e / o più bombe va bene, ma non è né richiesto né soggetto a bonus.

Produzione

La bomba originale è costituita da una tessera di 16x16 pixel, qui rappresentata sia in formato ASCII che binario:

....##..........    0000110000000000
.#.#..#.........    0101001000000000
.......#........    0000000100000000
#..#....#.......    1001000010000000
..#...#####.....    0010001111100000
......#####.....    0000001111100000
....#########...    0000111111111000
...###########..    0001111111111100
...###########..    0001111111111100
..#############.    0011111111111110
..########.####.    0011111111011110
...#######.###..    0001111111011100
...######.####..    0001111110111100
....#########...    0000111111111000
.....#######....    0000011111110000
.......###......    0000000111000000

In questa sfida, ogni bomba ASCII deve essere allungata al doppio della sua larghezza originale per un rendering migliore. Pertanto, sarà composto da 16 righe di 32 caratteri, usando ##per i pixel "ON" e due spazi per i pixel "OFF". Tutte le tessere bomba devono essere affiancate. Gli spazi guida sono vietati. Sono inoltre vietati gli spazi finali, ad eccezione di quelli che fanno effettivamente parte della tessera bomba (ovvero la 31a e la 32a colonna) che devono essere presenti. È possibile includere non più di un'interruzione di riga iniziale e non più di un'interruzione di riga finale.

Esempio

Di seguito è riportato l'output di riferimento per due bombe, in cui le interruzioni di riga obbligatorie sono contrassegnate come \ne le interruzioni di riga aggiuntive tollerate sono contrassegnate come (\n):

(\n)
        ####                            ####                    \n
  ##  ##    ##                    ##  ##    ##                  \n
              ##                              ##                \n
##    ##        ##              ##    ##        ##              \n
    ##      ##########              ##      ##########          \n
            ##########                      ##########          \n
        ##################              ##################      \n
      ######################          ######################    \n
      ######################          ######################    \n
    ##########################      ##########################  \n
    ################  ########      ################  ########  \n
      ##############  ######          ##############  ######    \n
      ############  ########          ############  ########    \n
        ##################              ##################      \n
          ##############                  ##############        \n
              ######                          ######            (\n)

(Naturalmente, anche altri formati di interruzione di riga come \ro \r\npossono essere utilizzati altrettanto bene.)

Regole

Questo è code-golf, quindi vince la risposta più breve in byte. Sono vietate le scappatoie standard.

code-golf  ascii-art  kolmogorov-complexity 
— Arnauld
fonte
Ho notato che hai escluso i moduli non ASCII, quindi una funzione di codice macchina Atari ST che si blocca con il giusto numero di bombe non conta. (La bomba non è nel tipo di carattere, ma l'Atari ST ha glifi divertenti / glifi delle uova di Pasqua nel suo set di caratteri nativi, inclusi i personaggi 28–31 che sono 4 pezzi che formano l'immagine di JR "Bob" Dobbs della Chiesa satirica del SubGenius . Ricordo di aver scritto un programma che spammava quei 4 glifi in posizioni casuali sullo schermo, come un esercizio molto precoce nell'uso delle chiamate di sistema di disegno di testo :)
— Peter Cordes,
1
@PeterCordes - Esatto, deve essere ASCII. Tuttavia, ti sarà permesso di leggere la grafica della bomba dalla ST ROM poiché non ci sono regole che ti impediscono di farlo. (Basta menzionare la versione TOS su cui dovrebbe funzionare.)
— Arnauld
1
Oh WOW, questo riporta ricordi. Il mio primo computer è stato un Atari ST. Ricordo quelle bombe con terrore.
— Rod
A parte: "Il numero di bombe dipende dal vettore di eccezione" - che dire ?! Qual è il motivo per cui non sono riusciti a visualizzare il codice / errore effettivo? (Non ho mai avuto una ST, vengo dal campo di Amiga ... "Guru Meditation" e tutto il resto.)
— MrWhite,

Risposte:

20

Gelatina , 43 44 byte

+1 byte - ho dimenticato di raddoppiare i caratteri (non che nessuno se ne sia accorto!)

“¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P"¦ḊƥṾ’b⁴‘ĖŒṙị⁾ #Ḥs⁴ẋ€³Y

TryItOnline

Come?

La preparazione è stata quella di comprimere i dati come una codifica della lunghezza dell'immagine originale:

  • Conta la lunghezza di ogni serie di 1s (spazio) o 0s (hash) nell'immagine, ignorando le nuove linee - genera un elenco [4,2,11,1,1,...]:;
  • Sottrai uno da ciascun numero: questo fornisce un intervallo di [0,15];
  • Considera questo come un numero di base 16 (enumera i valori v, con indice ial contrario e somma 16**i*v= = 19468823747267181273462257760938030726282593096816512166437);
  • Convertire questo in base-250 [5,119,249,42,...]:;
  • Mappa nella tabella codici di Jelly come indici: ¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P

Ora il codice valuta questo numero, mappa le 1s e 0s nello spazio e nei caratteri hash *, raddoppia ciascuno, si divide in linee e ripete ciascuna il numero appropriato di volte.
* in realtà l'implementazione viene eseguita modulo 2 per salvare i byte, quindi gli spazi sono dispari e gli hash sono pari:

“¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P"¦ḊƥṾ’b⁴‘ĖŒṙị⁾ #Ḥs⁴ẋ€³Y - Main link: n
“¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P"¦ḊƥṾ’                  - base 250 number, as above
                           b⁴                - convert to base 16 (the run length - 1 list)
                             ‘               - increment (vectorises) (the run length list)
                              Ė              - enumerate (pairs each with 1,2,3...)
                               Œṙ            - run length decode
                                              ([1,1,1,1,2,2,3,3,3,3,3,3,3,3,3,3,3,4,5,...])
                                  ⁾ #        - string " #"
                                 ị           - index into (1 based and modular)
                                              (makes a bomb without line feeds)
                                     Ḥ       - double (each char becomes a list of 2 chars)
                                      s⁴     - split into slices of length 16
                                        ẋ€³  - repeat each input, n, times
                                           Y - join with line feeds
— Jonathan Allan
fonte
19

05AB1E , 57 55 53 50 byte

Utilizza la codifica CP-1252 .

•ø6ŒY2l½î€ÈS`L<eÆô‚˜3ª½¨ºE»D2Âô3•b15ôvy1J€D„# è¹×,

Provalo online!

Spiegazione

Poiché l'immagine di output è composta solo da 2 caratteri, possiamo rappresentarla come un numero binario.
Possiamo ignorare le nuove righe poiché ogni riga ha la stessa lunghezza.
Possiamo ignorare l'ultimo carattere di ogni riga poiché è lo stesso per tutte le righe.
Usiamo l'immagine più sottile in quanto occupa meno spazio e possiamo facilmente duplicare ogni personaggio in seguito.

Usando 1 per rappresentare lo spazio e 0 per rappresentare # otteniamo il numero binario:

111100111111111101011011111111111111101111111011011110111111110111000001111111111000001111111100000000011111000000000001111000000000001110000000000000110000000010000111000000010001111000000100001111100000000011111110000000111111111100011111

Quindi convertiamo questo in base-10 e quindi lo comprimiamo in base 214, la base massima in 05AB1E. Il risultato di questo è:

•ø6ŒY2l½î€ÈS`L<eÆô‚˜3ª½¨ºE»D2Âô3•

La carne del programma consiste quindi di quanto segue:

<base encoded string>
  b                     # convert to binary
   15ô                  # slice into pieces of 15
      v                 # for each slice  
       1J               # append a 1       
         €D             # duplicate each character
           „#           # push the string "# "
             è          # use the list of binary digits to index into the string
              ¹×        # repeat string input number of times
                ,       # and print with newline
— Emigna
fonte
12

Pyth, 57 56 54 53 51 50 byte

Il codice contiene caratteri non stampabili, quindi ecco un xxdhexdump reversibile .

00000000: 6a2a 4c51 6331 3673 2e65 2a79 6240 2220  j*LQc16s.e*yb@"
00000010: 2322 6b6a 4322 4c49 c142 3c60 0cca 9437  #"kjC"LI.B<`...7
00000020: b383 76bb c246 c86d 4c04 99bd 3614 7022  ..v..F.mL...6.p"
00000030: 3137                                     17

Provalo online.

— PurkkaKoodari
fonte
11

JavaScript (ES6), 159 154 140 136 byte

Salvataggio di molti byte grazie a @Hedi e @Arnauld

n=>[..."ￏﾵｿﻶ쀇쀇考萃쐇숇ﱿ"].map(x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(x.charCodeAt()).repeat(n)).join`
`

Sono 104 caratteri, ma (purtroppo) 136 byte UTF-8. La stringa è stata generata con questo frammento:

Mostra snippet di codice

L'utilizzo al .replaceposto di [...string].mapè ugualmente lungo:

n=>"ￏﾵｿﻶ쀇쀇考萃쐇숇ﱿ".replace(/./g,x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(x.charCodeAt()).repeat(n)+`
`)

Come funziona

Poiché ogni riga dei dati non elaborati può essere rappresentata come un numero di 16 bit, possiamo archiviare l'intero file in una stringa di 16 caratteri. L'algoritmo di compressione prende ogni riga binaria, la inverte e la inverte (poiché ogni riga nell'originale termina con uno 0 , ogni riga nella versione modificata inizia ora con un 1 ), quindi la trasforma in un carattere e concatena i caratteri risultanti .

Per decomprimerlo, abbiamo bisogno di estrarre il charcode e trasformarne la rappresentazione binaria in una stringa di hash e spazi. Questo può essere fatto con una funzione ricorsiva, in questo modo:

(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(x.charCodeAt())

fprende ripetutamente l'ultimo bit di q, selezionando due spazi se è 1 o due hash se è 0, quindi lo concatena con il risultato della corsa fnel resto di q. Questo viene eseguito x.charCodeAt(), trasformando il codice carattere nella stringa corretta di spazi e hash.

(C'era molto più dramma qui prima, ma la tecnica di salvataggio a 4 byte ha cancellato tutto ciò.)

Dopodiché, possiamo semplicemente ripetere i ntempi delle stringhe e aggiungere una nuova riga. Questo è il metodo di decompressione più breve che ho trovato, ma sentiti libero di suggerire metodi eventualmente più brevi.

Altri tentativi di comprimere la stringa:

n=>[48,74,128,265,1988,1984,8176,16376,16376,32764,31740,15352,15864,8176,4064,896].map(x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(65535-x).repeat(n)).join`
`
n=>"1c,22,3k,7d,1j8,1j4,6b4,cmw,cmw,pa4,oho,bug,c8o,6b4,34w,ow".split`,`.map(x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(65535-parseInt(x,36)).repeat(n)).join`
`
n=>"30,4a,80,109,7c4,7c0,1ff0,3ff8,3ff8,7ffc,7bfc,3bf8,3df8,1ff0,fe0,380".split`,`.map(x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")('0x'+x^65535)).repeat(n)).join`
`

Il primo di questi è di 153 byte, quindi nessuno di essi arriva da nessuna parte vicino a 136 ...

— ETHproductions
fonte
Potrebbe salvare alcuni byte con +x?'##':' 'invece di" #"[x].repeat(2)
— Hedi,
@Hedi grazie, sapevo che c'era un modo per giocare a golf.
— ETHproductions
2
Potresti testare direttamente i bit x.charCodeAt()piuttosto che convertirli in binari? (Penso che risparmierebbe circa 8 byte.)
— Arnauld
2
Il tuo algoritmo di compressione sembra quasi crittografico .
— Giustino,
1
@Justin Damn, stavo per commentarlo.
— user253751
10

File .COM MS-DOS, 84 byte

OK. Solo per divertimento perché non posso battere i 50 byte ...

Provato in DOSbox e in MS-DOS 6.22 in una macchina virtuale.

In DOSbox il programma funziona bene, ma in MS-DOS reale l'output non verrà visualizzato correttamente perché DOS richiede CR-LF anziché LF alla fine della riga.

(Tuttavia l'output è corretto.)

Una variante a 88 byte userebbe CR-LF alla fine della riga.

Ecco il file:

0000  be 32 01 fc ad 89 c3 8a  36 82 00 80 ee 30 b9 10
0010  00 d1 c3 18 d2 80 ca 20  80 e2 23 b4 02 cd 21 cd
0020  21 e2 ee fe ce 75 e7 b2  0a cd 21 ad 85 c0 75 d5
0030  cd 20 00 0c 00 52 00 01  80 90 e0 23 e0 03 f8 0f
0040  fc 1f fc 1f fe 3f de 3f  dc 1f bc 1f f8 0f f0 07
0050  c0 01 00 00

Il codice assembler (nella sintassi AT&T) è simile al seguente:

start:
      # Read data from "image:"
    mov $image,%si
    cld
      # Read the first 16 bytes
    lodsw
nextLine:
      # Use bx as shift register
    mov %ax, %bx
      # Read the number of bombs
    mov 0x82,%dh
    sub $'0',%dh
nextBombInThisLine:
      # Number of characters
    mov $16, %cx
nextCharacter:
      # Rotate the data# get the next bit to CY
    rol $1, %bx
      # This results in 0x23 ('#') if CY is set, to 0x20 (' ') otherwise
    sbb %dl, %dl
    or $0x20, %dl
    and $0x23, %dl
      # Print result character twice
    mov $2, %ah
    int $0x21
    int $0x21
      # more Characters in this line?
    loop nextCharacter
      # More bombs to draw?
    dec %dh
    jnz nextBombInThisLine
      # Print a newline
#        mov $13, %dl # <- Additional 4 bytes needed for "\r\n"
#        int $0x21    #    at the end of the line!
    mov $10, %dl
    int $0x21
      # Read the next 16 bytes# 0x0000 means: EOF
    lodsw
    test %ax,%ax
    jnz nextLine
      # End of program
    int $0x20
image:
    # Here 34 bytes follow:
    # 16 16-bit-words "bitmap" for the bombs followed
    # by 0x0000 indicating the end of the bitmap

--- Modificare ---

Ho dimenticato di menzionare: il programma deve essere avviato con la seguente riga di comando:

Nome del file COM + esattamente un carattere spazio + Numero di bombe (1-9)

— Martin Rosenau
fonte
1
Bello. Ci manca ancora una risposta di 68000, ma questa si sta avvicinando. :-)
— Arnauld
objdump -dwl'output è un buon modo per mostrare il binario grezzo, poiché vedi quali byte sono quali istruzioni. L'ho fatto per le risposte gcd e adler32 . (Oltre a includere il codice sorgente commentato affinché le persone possano provare se stesse).
— Peter Cordes,
8

Python, 223 179 byte

Secondo approccio:

f=lambda n:'\n'.join(''.join(2*' #'[int(d)]for d in bin(int('0c0052000100908023e003e00ff81ffc1ffc3ffe3fde1fdc1fbc0ff807f001c0'[i:i+4],16))[2:].zfill(16))*n for i in range(0,64,4))

Provalo su repl.it!

Invece di creare un elenco di stringhe al volo, esiste una stringa esadecimale codificata che viene indicizzata e convertita in binario; quindi ogni cifra binaria viene trasformata in uno ' 'o '#', che viene duplicato e unito insieme ... ecc.

Primo approccio:

s='  ';b='##';f=lambda n:'\n'.join(n*l.ljust(32)for l in[s*4+b*2,(s+b)*2+s*2+b,s*7+b,b+s*2+b+s*4+b,s*2+b+s*3+b*5,s*6+b*5,s*4+b*9,s*3+b*11,s*3+b*11,s*2+b*13,s*2+b*8+s+b*4,s*3+b*7+s+b*3,s*3+b*6+s+b*4,s*4+b*9,s*5+b*7,s*7+b*3])

Provalo su repl.it!

Questo contiene un elenco hardcoded delle stringhe di ogni riga (esclusi gli spazi finali) create duplicando una ' 'o '##'più volte. Per ognuna di queste stringhe, sono riempite con spazi fino a 32 caratteri di lunghezza, ntempi duplicati , quindi unite con nuove righe.

— Hactar
fonte
È possibile salvare un byte passando alla stampa di un generatore non srotolato, anziché collegarsi '\n'. Quindi lambda n:print(*(''.join(2*' #'[int(d)]for d in bin(int('0c0052000100908023e003e00ff81ffc1ffc3ffe3fde1fdc1fbc0ff807f001c0'[i:i+4],16))[2:].zfill(16))*n for i in range(0,64,4))). Inoltre, non è necessario contare i byte necessari per assegnare un nome al lambda. Quindi il tuo punteggio può essere 176.
— Morgan Thrapp,
6

C, 250 240 208 188 byte

d[]={3072,20992,256,36992,9184,992,4088,8188,8188,16382,16350,8156,8124,4088,2032,448,0},m,c,*i=d;f(k){for(;*i;i++,puts(""))for(c=k;c--;)for(m=32768;m;write(1,&"##  "[m&*i?0:2],2),m>>=1);}

Passare a una funzione.

m,d[]={3072,20992,256,36992,9184,992,4088,8188,8188,16382,16350,8156,8124,4088,2032,448,0},*i=d;main(c,v)char**v;{for(;*i;puts(""),i++)for(c=atoi(v[1]);c--;)for(m=32768;m;write(1,&"##  "[m&*i?0:2],2),m>>=1);}

Prova in questo modo. main(c,v)char**v; { f(atoi(v[1])); } 

a.exe 2
        ####                            ####                        
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                    
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
— cleblanc
fonte
È possibile salvare alcuni byte utilizzando le rappresentazioni decimali di quei numeri esadecimali per perdere il valore 0x.
— Rame
@Copper Grazie, sono riuscito a radere parecchi byte anche usando write al posto di putchar.
— Cleblanc,
6

/// , 539 532 + n. di bombe byte

La prima /// risposta, con 4 bombe. Gli ultimi quattro 1 possono essere sostituiti con qualsiasi rappresentazione unaria del numero di bombe che si desidera stampare (11 per 2, 111 per 3)

/-/?|X//y/\/X//xy|//|/\/\///+/%@!|$/bcd|%/efg|@/hij|!/klm|?/nop|b/Bxc/Cxd/Dxe/Exf/Fxg/Gxh/Hxi/Ixj/Jxk/Kxl/Lxm/Mxn/Nxo/Oxp/Pxq/ss|r/tt|s/SS|t/TT|S/  |T/##|1/AX$+-$+?AXyAX$+-cd+?by$+-d+?cycd+-+?dyd+-fg@!?ey+-g@!?fyfg@!-@!?gyg@!-ij!?hy@!-j!?iyij!-!?jyj!-lm?ky!-m?lylm-?mym-opny-poyop|AXA/AA|bB/BB|cC/CC|dD/DD|eE/EE|fF/FF|gG/GG|hH/HH|iI/II|jJ/JJ|kK/KK|lL/LL|mM/MM|nN/NN|oO/OO|pP/PP|A/qtqqs|B/STSTsTqqS|C/qsSTqq|D/TsTqTqsS|E/sTsSrTqS|F/qsrTqS|G/qrrTsS|H/sSrrtTs|I/sSrrtTs|J/srrrTS|K/srrSrS|L/sSrtTStTs|M/sSrtSrs|N/qrrTsS|O/qSrtTq|P/qsStTqs|X/
/1111

Provalo online!

Se l'ingresso deve essere decimale, quanto segue ha 555 548 byte (dove l'ultima cifra può essere cambiata in 1, 2, 3 o 4):

/-/?|X//y/\/X//xy|//|/\/\///4/13|3/12|2/11|^/tT|&/rr|*/sS|+/%@!|$/bcd|%/efg|@/hij|!/klm|?/nop|b/Bxc/Cxd/Dxe/Exf/Fxg/Gxh/Hxi/Ixj/Jxk/Kxl/Lxm/Mxn/Nxo/Oxp/Pxq/ss|r/tt|s/SS|t/TT|S/  |T/##|1/AX$+-$+?AXyAX$+-cd+?by$+-d+?cycd+-+?dyd+-fg@!?ey+-g@!?fyfg@!-@!?gyg@!-ij!?hy@!-j!?iyij!-!?jyj!-lm?ky!-m?lylm-?mym-opny-poyop|AXA/AA|bB/BB|cC/CC|dD/DD|eE/EE|fF/FF|gG/GG|hH/HH|iI/II|jJ/JJ|kK/KK|lL/LL|mM/MM|nN/NN|oO/OO|pP/PP|A/qtqqs|B/STSTsTqqS|C/q*Tqq|D/TsTqTq*|E/sT*rTqS|F/qsrTqS|G/q&T*|H/*&^s|I/*&^s|J/s&rTS|K/s&SrS|L/*r^S^s|M/*rtSrs|N/q&T*|O/qSr^q|P/q*^qs|X/
/4

Provalo online!

Le parti più importanti del codice sono:
| significa //
ABCDEFGHIJKLMNOP significa ogni linea della bomba rispettivamente
S significa 2 spazi
s significa 4 spazi
* significa 6 spazi
q significa 8 spazi
T significa ## (2)
t significa #### (4)
^ significa ##### # (6)
r significa ######## (8)
e significa ################ (16)
La maggior parte del codice si assicura che le bombe siano stampate fianco a fianco, non uno sopra l'altro.

— boboquack
fonte
5

CJam , 66 byte

"^a1{9\b aZ5w7qQAwndIUffO"136b2b1Ser0'#erG/ri*z{:_N}%

Provalo online! (nota che ci sono alcuni caratteri non stampabili nel codice.)

La bomba è codificata come un numero in binario usando 1 per gli spazi (lo spazio iniziale come 1 assicura che non dobbiamo riempire le rappresentazioni binarie), trasposto e quindi convertito in stringa in base-136 (che ha prodotto la stringa più corta senza caratteri ampi). Questi passaggi possono essere giocati qui .

Questa risposta inverte quindi la codifica, il trucco principale è ripetere la bomba prima di trasporre, concatenando efficacemente ogni linea della bomba in una sola volta. I caratteri in ciascuna riga possono quindi essere raddoppiati con le nuove righe inserite per l'output finale.

— Linus
fonte
5

PHP, 138 104 + 32 = 136 byte

Non avevo mai pensato che filefosse binario sicuro. Vorrei solo che avrei trovato un modo più interessante per archiviare i dati; ma nulla di ciò che ho provato ha battuto binario raw

foreach(unpack("v*",file(b)[0])as$v)echo"
",str_repeat(strtr(sprintf("%016b",$v),["  ","##"]),$argv[1]);
  • leggere i dati binari dal file, decomprimere da little endian 16 bit alla matrice di int
  • loop loop: stampa binario a 16 cifre su stringa, sostituisci 0con 2 spazi, 1con ##,
    ripeti i $argv[1]tempi, stampa i risultati + nuova riga

Corri con -r

dati binari nel file b:

0000000 0c00 5200 0100 9080 23e0 03e0 0ff8 1ffc
0000010 1ffc 3ffe 3fde 1fdc 1fbc 0ff8 07f0 01c0

codice per generare il file:

$f=fopen(b,wb);foreach(array_map(bindec,explode("
",
"0000110000000000
0101001000000000
0000000100000000
1001000010000000
0010001111100000
0000001111100000
0000111111111000
0001111111111100
0001111111111100
0011111111111110
0011111111011110
0001111111011100
0001111110111100
0000111111111000
0000011111110000
0000000111000000"))as$c)fputs($f,pack("v*",$c));fclose($f);
— Titus
fonte
2
È possibile salvare 2 byte utilizzando un'interruzione di linea iniziale anziché una di fine riga e quindi non avere lo spazio dopo l'eco e utilizzando un'interruzione di linea effettiva anziché \n.
— user59178
@utente59178 Lo so. non così prolisso per favore.
— Tito
5

MATL , 64 63 60 59 58 byte

49:',cxJr(v9hW&waHB`U=NL%)C9[$aoAN'F16ZaQEY"32e!' #'w)liX"

Provalo online!

Spiegazione

Il codice utilizza una versione precompressa della matrice binaria 16 × 16. La pre-compressione (non parte del programma) utilizzava due passaggi:

  1. Codifica run-length della matrice letta in ordine di riga maggiore (prima attraverso, poi verso il basso).
  2. Le lunghezze di esecuzione risultanti vanno da 1 a 16, quindi il vettore delle lunghezze meno 1 è stato convertito dalla base 16 alla base 94 (per utilizzare tutti i codici ASCII stampabili tranne la virgoletta singola, che non viene utilizzata perché avrebbe bisogno di scappare).

La stringa compressa,

   ',cxJr(v9hW&waHB`U=NL%)C9[$aoAN'

viene decompresso dalla base 94 alla base 16:

                                   F16Za

Il vettore ottenuto di lunghezze di marcia più 1 è moltiplicato per 2:

                                        QE

per eseguire l'allungamento orizzontale.

Il vettore delle lunghezze contiene 49 valori. I numeri originali da ripetere con quelle lunghezze dovrebbero essere [0 1 0 1 ... 0](49 voci). Invece, è più breve usare il vettore [1 2 ... 49], che sarà ugualmente valido grazie all'indicizzazione modulare. Quindi la decodifica della lunghezza è

49:                                       Y"

Il vettore generato containis le piste di 1, 2, ... 49, per un totale di 512 voci. Questo è rimodellato in una matrice 16 × 32:

                                            32e!

e usato come indici modulari nella stringa ' #'per produrre una singola bomba:

                                                ' #'w)

Infine, la ripetizione orizzontale di un fattore dato dall'input produce il risultato desiderato:

                                                      liX"
— Luis Mendo
fonte
4

Python 2: 143 byte

n=input()
j=2
while j<258:print''.join(2*'# '[b>'0']for b in bin(int('62XI2JG3U2Q0COCDFCZAMC8A9LAP6W1ZMM4A59GC43M49ENF3Z',36))[j:j+16])*n;j+=16

È a ideone

(Mi sono reso conto che la codifica diretta della bomba originale nella base 36 ha reso il codice più breve in Python.)

La stringa è stata formata trattando gli spazi come 1 e gli hash come 0, quindi convertendoli in base 36. Il programma quindi converte nuovamente in binario e sezioni in lunghezze di 16 (con un offset di 2 per lo '0b' nella parte anteriore di Python stringa binaria), converte in doppi spazi e doppi hash, li unisce, ripete i ntempi della stringa e stampa.

Precedente: Python 2, 169 166 163 byte

n=input()
j=0
while j<512:print''.join(' #'[i%2]*2*(v+1)for i,v in enumerate(int(c,16)for c in'31A00010F07010308024A4885A4A3C2703360245035876A25'))[j:j+32]*n;j+=32

È a ideone

Quasi un porto della mia risposta Jelly .

— Jonathan Allan
fonte
Inefficiente è buono se è più corto. Nice +1
— ElPedro
4

Python 2.7, 144 141 byte

x=input()
for i in range(16):print"".join(" #"[b<"1"]*2for b in bin(int("5ZCAZKAVTP6J04W4VZJ2BQDH5DASIKRS524V8SWRSIVWZEWC8V",36))[2+i::16]*x)

La bomba è scritta in binario con 1 per lo spazio, il primo 1 rimuove la necessità di riempire le rappresentazioni binarie. La bomba viene trasposta (proprio come nella mia risposta CJam ) e conservata nella base 36.

Il programma decodifica la bomba in binario e itera i bit di un passo di 16 in modo efficace seguendo la trasposizione (che consente di risparmiare byte tagliando una determinata linea). La linea risultante viene concatenata, i bit vengono sostituiti con il doppio o #, e uniti in una stringa singola.

— Linus
fonte
1
Puoi eliminare lo zero iniziale dal numero 36 di base.
— Jonathan Allan,
@JonathanAllan: Bella cattura. Ho pensato che fosse Oper qualche motivo ...
— Linus,
4

C (gcc) , 216 204 183 165 134 byte

b(n,i){for(n*=16,i=--n*16;i--;i%n||puts(""))printf(L"àϸ\x7fc\xfde\xfee`\x1fff\xffe\xffe\x7fcǰᇰ䡀\x80⤀\x600"[i/n]&1<<i%n%16?"##":"  ");}

Provalo online!

Scritto come programma autonomo ( 201 183 151 byte)

i=16;main(j,l)char**l;{for(;i--;puts(""))for(j=*l[1]*16-769;j--;printf(L"àϸ\x7fc\xfde\xfee`\x1fff\xffe\xffe\x7fcǰᇰ䡀\x80⤀\x600"[i]&1<<j%16?"##":"  "));}

Provalo online!

Ciò segfault se non viene fornito un parametro della riga di comando.

— ceilingcat
fonte
3

Lotto, 415 byte

@echo off
set h=#####
set s=
for %%a in ("    ##%s%%s%" " # #  #%s%    " "%s%  #%s%   " "#  #    #%s%  " "  #%h%%s%" "%s% %h%%s%" "    %h%####   " "   %h%%h%#  " "   %h%%h%#  " "  %h%%h%### " "  %h%### #### " "   %h%## ###  " "   %h%# ####  " "    %h%####   " "%s%%h%##    " "%s%  ###%s% ")do call:l %1 %%a
exit/b
:l
set r=
for /l %%i in (1,1,%1) do call set r=%%r%%%~2
set r=%r: =  %
echo %r:#=##%

Nota: la linea set s=termina in 5 spazi. Accetta il conteggio come parametro della riga di comando. Passa semplicemente attraverso ciascuna linea della bomba (compressa leggermente rimuovendo le corse di 5 personaggi identici), quindi ripete la bomba quante volte desideri prima di duplicare finalmente ogni personaggio.

— Neil
fonte
3

Python 2, 206 205 203 199 191 188 186 184 160 160 byte

z=input()
for y in 3072,20992,256,36992,9184,992,4088,8188,8188,16382,16350,8156,8124,4088,2032,448:print"".join(" #"[e>0]*2for e in map(int,bin(y+8**6)[5:]))*z

Ho esaminato Hex per l'elenco dei numeri, ma non mi è sembrato di salvare abbastanza per far valere lo sforzo. Speravo di essere in grado di decodificare il codice, ma sembra che sia arrivato il più lontano possibile con questo approccio. Eventuali suggerimenti aggiuntivi ricevuti con gratitudine.

MODIFICARE

-1 cambiando e==1in e>0. Lo dimentico sempre.

-2 ignorando la lunghezza della stringa binaria, anteponendo 7 0 e prendendo solo gli ultimi 16 elementi. Funziona in quanto non ci sono mai più di 7 0 iniziali.

-4 perché ora che ho perso il secondo riferimento alla variabile b posso usarlo bin(y)[2:]direttamente nella funzione mappa portandolo sotto la magia 200 :-)

-8 usando l'assegnazione delle sezioni nel secondo elenco. Ho imparato qualcosa di nuovo questa sera.

-3 grazie a @Jonathan

-2 usando c=d=([0]*7+map(int,bin(y)[2:]))[-16:]invece di averec=d;

-2 ancora grazie a @Jonathan

-24 grazie a @Linus

Produzione

python bombs.py
2
        ####                            ####                    
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
— ElPedro
fonte
" #"[e>0]*2funzionerà
— Jonathan Allan il
DOH! Come ho perso quello ??? Grazie @ Jonathan
— ElPedro il
... anche le parentesi (...)possono andare (RE: per il mio commento precedente).
— Jonathan Allan,
Puoi portarlo a 170 confor y in ...:print"".join(" #"[e>0]*2for e in(([0]*7+map(int,bin(y)[2:]))[-16:]))*z
— Jonathan Allan il
@Jonathan Grazie ancora. si sta facendo tardi qui, quindi salverò quel cambiamento per domani, quindi non lo rovinerò completamente.
— ElPedro,
3

RProgN , 210 193 byte

Ho salvato alcuni byte cambiando 0 = '' 1 = '##' in 1 = '' 0 = '', questo significa che non ho bisogno di aggiungere nuovamente gli zeri extra. Inoltre, questo significa che ora la stringa B64 che era solito dire "MAFIA" non lo fa, questo è triste.

'n' = => 64 -B 2 B ] 1 16 sub n rep \ 17 32 sub n rep '
' \ . . '1' '  ' replace '0' '##' replace } a'' = D4D/4/'' a DgQ/AH'' a DAIeAj'' a DgA8AB'' a DwB+AD'' a DcH/wf'' a D+/29/'' a Dz/63/'' a

Spiegazione

'n' =                   # Associate the input with "n"
=>                      # Push a new function to the stack.
    64 -B               # Take the value from the top of the stack, convert it to an integer from Base64
    2 B                 # Take the value from the top of the stack, convert it from an integer to binary
    ]                   # Duplicate the top of the stack.
    1 16 sub            # Push the substring from the top of the stack between 1 and 16, 1 indexed.
    n                   # Push the input.
    rep                 # Repeat, this gives us 'n' bombs, essentially.
    \                   # Flip the values such that REPEATEDBOMB_ROW TEXT
    17 32 sub           # Push the substring between 17 and 32.
    n                   # Push the input
    rep                 # Repeat
    '                   # Push a new line
'                       # RProgN doesn't actually have escapes, so the raw newline is represented as a newline between qoutes.
    \ . .               # Flip the values so we have LINE1 NEWLINE LINE2, then concatenate them all into one string.
    '1' '  ' replace    # Replace all the 1's in the binary string with two spaces.
    '0' '##' replace    # Replace all the 1's with two '#'s
} a'' =                 # Associate the function with 'a'
D4D/4/'' a              # Bottom two lines,
DgQ/AH'' a              # Next two up,
DAIeAj'' a              # Etc...
DgA8AB'' a              # Once This is done, the memory stack is implicitly printed from top to bottom.
DwB+AD'' a              # As such, the bomb is upside down.
DcH/wf'' a              # Each of these numbers represents two lines, which is why we do the substringing to split it.
D+/29/'' a              # This works out saving a few bytes.
Dz/63/'' a              # Implicitly printed output. Yay.

Abbastanza lungo, l'espansione, la stampa e tale della stringa compressa è 105 dei byte. Potrebbe essere un po 'più golfabile, ma almeno funziona.

L'input è implicitamente nello stack, lo stack è implicitamente stampato.

Produzione

        ####                            ####                            ####                    
  ##  ##    ##                    ##  ##    ##                    ##  ##    ##                  
              ##                              ##                              ##                
##    ##        ##              ##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########              ##      ##########          
            ##########                      ##########                      ##########          
        ##################              ##################              ##################      
      ######################          ######################          ######################    
      ######################          ######################          ######################    
    ##########################      ##########################      ##########################  
    ################  ########      ################  ########      ################  ########  
      ##############  ######          ##############  ######          ##############  ######    
      ############  ########          ############  ########          ############  ########    
        ##################              ##################              ##################      
          ##############                  ##############                  ##############        
              ######                          ######                          ######

Provalo!

<style>
  #frame{
    width:60em;
    height:60em;
    border:none;
  }
</style>
<iframe id='frame' src="https://tehflamintaco.github.io/Reverse-Programmer-Notation/RProgN.html?rpn=%27n%27%20%3D%20%3D%3E%2064%20-B%202%20B%20%5D%201%2016%20sub%20n%20rep%20%5C%2017%2032%20sub%20n%20rep%20%27%0A%27%20%5C%20.%20.%20%271%27%20%27%20%20%27%20replace%20%270%27%20%27%23%23%27%20replace%20%7D%20a%27%27%20%3D%20D4D%2F4%2F%27%27%20a%20DgQ%2FAH%27%27%20a%20DAIeAj%27%27%20a%20DgA8AB%27%27%20a%20DwB%2BAD%27%27%20a%20DcH%2Fwf%27%27%20a%20D%2B%2F29%2F%27%27%20a%20Dz%2F63%2F%27%27%20a&input=1">Sorry, You need to support IFrame. Why don't you..?</iframe>
Espandi frammento

— ATACO
fonte
3

PHP, 144 140 139 138 136 byte

Nota: utilizza la codifica Windows-1252

for(;$j%=32*$argn or$r=intval(substr("01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow",$i++*3,3),36)*print~õ;)echo~ßÜ[$r>>$j++/2%16&1];

Esegui in questo modo:

echo 2 | php -nR 'for(;$j%=32*$argn or$r=intval(substr("01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow",$i++*3,3),36)*print~õ;)echo~ßÜ[$r>>$j++/2%16&1];'

O usando la codifica IBM-850 (135 byte e risultato più bello):

echo 2 | php -nR 'for(;$j%=32*$argn or$r=intval(substr(~¤╬£¤══¤╠ö¤╚ø╬òÃ╬ò╦╔Ø╦£Æê£ÆêÅ×╦ÉùÉØèÿ£ÃÉ╔Ø╦╠╦ê¤Éê,$i++*3,3),36)*print~§;)echo~▀M[$r>>$j++/2%16&1];'

        ▓▓▓▓                            ▓▓▓▓                    
  ▓▓  ▓▓    ▓▓                    ▓▓  ▓▓    ▓▓                  
              ▓▓                              ▓▓                
▓▓    ▓▓        ▓▓              ▓▓    ▓▓        ▓▓              
    ▓▓      ▓▓▓▓▓▓▓▓▓▓              ▓▓      ▓▓▓▓▓▓▓▓▓▓          
            ▓▓▓▓▓▓▓▓▓▓                      ▓▓▓▓▓▓▓▓▓▓          
        ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓              ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓      
      ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓          ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓    
      ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓          ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓    
    ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓      ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  
    ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓      ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓  
      ▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓          ▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓    
      ▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓          ▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓    
        ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓              ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓      
          ▓▓▓▓▓▓▓▓▓▓▓▓▓▓                  ▓▓▓▓▓▓▓▓▓▓▓▓▓▓        
              ▓▓▓▓▓▓                          ▓▓▓▓▓▓

Spiegazione

Questo non fa nulla di binario e non richiede un file esterno.

Ogni numero di 16 bit viene invertito, quindi codificato come un numero di base 36, riempito con un carattere iniziale 0se necessario, quindi ogni 16 bit genera 3 byte. Concatenare questi risultati in 01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow. Il codice inverte il processo in modo che le bombe vengano stampate correttamente Nvolte.

Ritocchi

  • Salvato 4 byte utilizzando solo un singolo for-loop
  • Salvato un byte stampando un singolo carattere per ogni iterazione e usando l'indice di stringa anziché ternario
  • Salvare un byte ottenendo il ripristino $ja zero dei limiti di linea con %=. Questo elimina le parentesi
  • Salvato 2 byte utilizzando $argn
— aross
fonte
3

GCC C 129 byte

ISO8859 / ASCII

f(r,i,d){
    for(;i<32;i+=2,puts(""))
        for(d=15*r;--d;)
             printf((*(int*)&("ÿóÿ­ÿþoÜüðààÀ!ÀCÀCàðø?þ"[i]))&(1<<d%15)?"  ":"##");
}

In una riga:

f(r,i,d){for(;i<32;i+=2,puts(""))for(d=15*r;--d;)printf((*(int*)&("ÿóÿ­ÿþoÜüðààÀ!ÀCÀCàðø?þ"[i]))&(1<<d%15)?"  ":"##");}

Corri con:

main(c,v)char**v;{f(atoi(v[1]),0)}

Compilare l'origine come ISO8859-x (ASCII).

NB óÿÿþÿoÜüðààÀÀ! ÀCàCðøþ? dovrebbe contenere i codici ASCII invisibili ma è stato rotto a causa del modo in cui StackExchange presenta il suo contenuto. Si prega di consultare il link ideaone per una corretta codifica di prova In alternativa, la stringa ASCII originale è su: https://github.com/claydonkey/AtariBombs/blob/master/ISO8859_REPR2.txt

Spiegazione

Prima una conversione della rappresentazione esadecimale delle bombe [f3 ff ad ff fe ff 6f 7f dc 1f fc 1f f0 07 e0 03 e0 03 c0 01 c0 21 c0 43 e0 43 f0 07 f8 0f fe 3f] in UTF-8 (nella Versione UTF-8 il compilatore memorizza la stringa come Wide Char Array - 2 o 4 byte per ogni personaggio in fase di esecuzione ma questo è accademico). Mentre i caratteri UTF-8 verrebbero memorizzati come 2-4 byte, questi valori sono tutti all'interno di ISO-8859-1 (ASCII) e quindi richiedono solo 1 byte. Inoltre è sicuro essere memorizzati come ISO-8859-x (non ci sono valori 0x8_ o 0x9_). Pertanto il testo consuma 32 byte in ISO-8859 e la routine consuma 135 byte in totale.

(NB i caratteri wide sono archiviati come numero intero a 16 bit in Windows e 32 bit in Linux, ma questo è ancora irrilevante per l'attività in corso)

Avvertenza: non tutti i personaggi sono visualizzabili (i caratteri di controllo sotto 0x20), ma sono comunque presenti. La maggior parte delle pagine Web sono utf-8 / 8859/1253 ( https://w3techs.com/technologies/overview/character_encoding/all ) quindi ritengo che questo sia legittimo (spostando tutti i valori inferiori a 0x20 in ASCII stampabile dovrebbe risolverlo).

UTF-8

Ecco la versione più vicina alla pubblicazione originale con sorgente codificata UTF-8. Ciò consuma 173 byte. La stringa stessa è 50 byte della sorgente. La routine è anche più lunga in quanto i byte ASCII sono ora memorizzati con il riempimento di 0 per i caratteri larghi 16bit / 32bit e devono essere spostati invece di essere lanciati su uint16_t come sopra. Ho continuato così perché può essere verificato con ideone che utilizza la codifica UTF-8.

*w=L"óÿ­ÿþÿoÜüðààÀÀ!ÀCàCðøþ?";
f(r,i,j,m){
    for(i;i<32;i+=2,puts(""))
        for(j=r;j--;)
            for(m=65536;m>1;(m\=2,printf(((w[i]<<8)+w[i+1]&m)?"  ":"##")));}

Corri con:

main(c,v)char**v;{f(atoi(v[1]),0)}

Se puoi impostare il valore implicito su un numero intero a 16 bit nel tuo complier, puoi omettere la dichiarazione di tipo wchar_t di Wide Char. Ideone non si lamenta, quindi penso che sia bello andare.

Provalo su ideone

— claydonkey
fonte
Degno di nota. Quale codifica utilizza questo?
— DJMcMayhem
È compilato su MinGW GCC dove un personaggio ampio è un uint16. Pertanto la codifica è [tipo a 16 bit con UTF-16 Unicode]. Tuttavia, penso che poiché i caratteri si trovano all'interno di 0xFF (16 bit) sono estesi ASCII. + Quindi niente di speciale
— claydonkey,
Mi dispiace di aver appreso un po 'di più sulla codifica e potrebbe essermi sbagliato a memorizzarlo come UTF-16. fare riferimento alla risposta revisionata.
— Claydonkey,
2

Haskell, 155 byte

In funzione del tipo Int -> String:

b z=concat$do y<-[0..15];"\n":[if odd$div 0x3800FE01FF03DF83BF87BFC7FFC3FF83FF81FF007C007C401090080004A0030(2^(16*y+x))then"##"else"  "|x<-[1..z]>>[0..15]]

La stampa diretta su IO avrà un costo di 5 byte (o 6 se si preferisce restituire IO ()anziché IO [()]):

b z=mapM putStr$do y<-[0..15];"\n":[if odd$div 0x3800FE01FF03DF83BF87BFC7FFC3FF83FF81FF007C007C401090080004A0030(2^(16*y+x))then"##"else"  "|x<-[1..z]>>[0..15]]
— Nick Hansen
fonte
2

C, 175 byte

 x[]={48,74,128,265,1988,1984,8176,16376,16376,32764,31740,15352,15864,8176,4064,896};f(z,p){while(z++<16){p=1;while(p<<=1){printf("%s",p&(x[z]<<16|x[z])?"##":" ");}puts("");}}

concatena ogni x a se stessa e fa p overflow per terminare ogni riga.

ah, ho cambiato printf () per scrivere durante il golf e questo l'ha rotto. prova qui ideone.com/JtHInD
2

Java, 228 byte

import static java.lang.System.out;

public class Bombs
{
    public static void main(String[] args)
    {
        new Bombs().d(2);
        new Bombs().d(3);
        new Bombs().d(4);
    }

    void d(int n){String s="";for(int x=16,r=0;r<16*n;x=16,s+=(++r%n==0?"\n":""))while(--x>=0)s+=((new int[]{1536,10496,128,18496,4592,496,2044,4094,4094,8191,8175,4078,4062,2044,1016,224}[r/n])&(1<<x))==0?"  ":"##";out.println(s);}

}
— Marco13
fonte
1
So che è passato un anno, ma puoi giocare a questo: n->{String s="";for(int x,r=0;r<16*n;s+=(++r%n<1?"\n":""))for(x=16;x-->0;)s+=((new int[]{1536,10496,128,18496,4592,496,2044,4094,4094,8191,8175,4078,4062,2044,1016,224}[r/n])&(1<<x))<1?" ":"##";return s;}( 205 byte ) Oltre a usare un lambda Java 8, ho ridotto più byte cambiando: la posizione del x=16(e cambiando whilein for); 2x ==0a <1; restituendo sinvece di stamparlo (anche le importazioni fanno parte del conteggio dei byte tra ..); --x>=0a x-->0. Comunque, ottima risposta, quindi +1!
— Kevin Cruijssen,
@KevinCruijssen Grazie (considera di postare questo come una risposta personale). Non sono così attivo qui su codegolf, e quindi non sono sicuro delle regole, ma penso che nella maggior parte dei casi, sia consentito solo contare i byte della funzione (e ignorare le importazioni).
— Marco13,
È un po 'troppo simile per pubblicare come risposta separata, ma posso capire se non vuoi modificare la tua risposta più di un anno fa. :) Lo lascerò nel commento. E temo che le importazioni contino davvero per il conteggio dei byte.
— Kevin Cruijssen,
2

J, 89 byte

|:@;@#&(<' #'{~2#|:16 16$}.2#.inv 95#.32x-~3 u:'u,:C>%}UwPXHn_C9wF.|U ap<{jH%O9 9wRThGs')

Codifica la stringa come un numero base-95, incrementa ogni cifra di 32, quindi la rappresenta con una stringa ASCII.

Spiegazione

Questo è composto da due parti principali. C'è la costruzione della bomba e l'effettiva ripetizione. Facciamo per il momento riferimento alla bomba come b. Quindi, il codice appare come:

|:@;@#&(b)

Se chiamato con input k, questo equivale a:

|: ; (k#b)

bè una bomba scatolata, quindi k#beffettua kripetizioni b, la ;appiattisce verticalmente e |:traspone il risultato. (La bomba bstessa è stata costruita trasposta.)

Ora, ecco la bomba:

<' #'{~2#|:16 16$}.2#.inv 95#.32x-~3 u:'u,:C>%}UwPXHn_C9wF.|U ap<{jH%O9 9wRThGs'

La stringa che segue è una stringa codificata in base 95 con un offset di 32, in modo che tutti i caratteri rientrino nell'intervallo ASCII e per fortuna non ci sono messaggi 'che devono essere salvati. 3 u:ottiene i codici char della stringa, 32x-~trasforma ogni numero in un xnumero teso e ne sottrae 32; 95#.converte in un numero base-95 e 2#.invlo converte in un array di cifre binarie. Ho aggiunto un lead 1al binario per renderlo un numero solido, quindi lo tolgo con }.. Modifico l'array in una tabella 16x16 per 16 16$poi trasporlo usando |:. (Possibile golf per dopo: trasporre la stringa codificata letterale.) 2#Duplica ogni carattere in larghezza. Ci rimane una tabella di 0s e 1s.' #'{~mappe 0da ' 'e 1verso '#'. Così, siamo rimasti con la nostra bomba.

Caso di prova

   |:@;@#&(<' #'{~2#|:16 16$}.2#.inv 95#.32x-~3 u:'u,:C>%}UwPXHn_C9wF.|U ap<{jH%O9 9wRThGs') 3
        ####                            ####                            ####
  ##  ##    ##                    ##  ##    ##                    ##  ##    ##
              ##                              ##                              ##
##    ##        ##              ##    ##        ##              ##    ##        ##
    ##      ##########              ##      ##########              ##      ##########
            ##########                      ##########                      ##########
        ##################              ##################              ##################
      ######################          ######################          ######################
      ######################          ######################          ######################
    ##########################      ##########################      ##########################
    ################  ########      ################  ########      ################  ########
      ##############  ######          ##############  ######          ##############  ######
      ############  ########          ############  ########          ############  ########
        ##################              ##################              ##################
          ##############                  ##############                  ##############
              ######                          ######                          ######
— Conor O'Brien
fonte
2

BaCon , 229 227 195 byte

Un contributo in BASIC per amore della nostalgia. La variabile "a" determina la quantità di bombe.

a=2:FOR x=0 TO 15:FOR y=1 TO a:FOR i=15 DOWNTO 0:?IIF$(v[x]&INT(POW(2,i)),"##","  ");:NEXT:NEXT:?:NEXT:LOCAL v[]={3072,20992,256,36992,9184,992,4088,8188,8188,16382,16350,8156,8124,4088,2032,448}

Uscita :

        ####                            ####                    
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
— Peter
fonte
2

Haskell, 191 181 byte

f n=h n:f(div n 2)
h n|odd n=' '
h _='#'
g b=mapM_ putStrLn[[f 0xfc7ff01fe00fc207c40784038003c007c007e00ff83ff83bfef6ff7fffb5ffcf!!(x`mod`32`div`2+y*16)|x<-[0..32*b-1]]|y<-[0..15]]
— Angs
fonte
2

C (Atari TOS 2.06 US), 129 124 117 113 byte

short*a=0xe013b0;main(j,l)char**l;{for(;*a++-224;puts(""))for(j=*l[1]*16-768;j--;printf(*a&1<<j%16?"##":"  "));}

Questo utilizza la bitmap della bomba dalla ROM TOS, che è leggermente diversa da quella nella domanda. Per altre versioni di TOS, dovrai regolare l'indirizzo indicato da *a. Nota che alcune rom dell'emulatore non includono la bitmap della bomba!

Se non fornisci un argomento da riga di comando, potrebbero essere visualizzate diverse bombe bitmap ad alta risoluzione :-)

— ceilingcat
fonte
1

C ++ 11, 252 byte

#include <iostream>
using namespace std;string d("01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow");int main(){for(int i=0;i!=45;i+=3){int z=stoi(d.substr(i,3),NULL,36);for(unsigned long p=1;p!=1<<31;p<<=1){cout<<(((z<<16|z)&p)?"##":"  ");}puts("");}}
1

SmileBASIC, 127 byte

INPUT N
FOR J=0TO 15FOR K=1TO N
FOR I=0TO 14?" #"[1AND ASC("xxxxxxxxxxxxxxx"[I])>>J]*2;
NEXT
NEXT?NEXT

immagine dello schermo
(Schermata della versione senza caratteri raddoppiati)
SB ha un carattere quadrato, quindi raddoppiare i caratteri sembra male (e non si adatta allo schermo)
I caratteri non ASCII sono stati sostituiti da quelli xdi.
Valori esadecimali: 0008,0002,0610,1F8A,3FC1,7FC1,7FF2,FFF4,FFF8,EFF0,73F0,7FC0,3FC0,1F80,0600
poiché SB salva i file in UTF-8, alcuni di questi contano come 2 o 3 byte.

— 12Me21
fonte
@Arnauld Non so molto su SmileBASIC, ma dato che c'è un loop FOR K=1TO Ncon INPUT N, penso che mostri il numero di bombe fornite nell'input. Tuttavia, devo dire che, nonostante il carattere quadrato, credo che i personaggi debbano comunque essere raddoppiati per essere coerenti con i requisiti (per evitare un vantaggio rispetto ad altre risposte). Potresti mantenere quella attuale per una soluzione più bella, ma penso che dovresti ancora aggiungere una soluzione corretta. Una volta aggiunto questo, voterò per l'uso creativo dei caratteri UTF-8!
— HyperNeutrino,
@AlexL. Sì, il mio commento era precedente all'aggiornamento del codice.
— Arnauld,
1

Ruby 2.x (lambda) - 157 byte

Probabilmente può essere ulteriormente giocato a golf, ma mi piace questa versione:

->n{puts "0c0052000100908023e003e00ff81ffc1ffc3ffe3fde1fdc1fbc0ff807f001c0".scan(/.{4}/).map{|x|(("%016b"%x.to_i(16)).tr("10","# ").chars.map{|c|c+c}*"")*n}}

Idea simile alle versioni di Python: spezza la stringa di bombe codificate esadecimali in sezioni di 4 caratteri, converti in binario, traduci 1in #e 0in , raddoppia ogni carattere e stampa l'array risultante.

Si noti che put viene utilizzato per stampare l'array. Questo stamperà l'array di una riga per elemento.

— Nerketur Kamachi
fonte
1

Excel VBA, 204 byte

Anonimo VBE Funzione finestra immediata che accetta input dall'intervallo [A1]e output all'oggetto ActiveSheet

Cells.RowHeight=48:For i=0To[A1-1]:[A4,B2,C5,D4,D2,E1:F1,G2,H3,I4,G5:K6,E7:M7,D8:N9,C10:J11,K10:O10,O11,L11:N13,K13:K15,L14:L15,M14,D12:I13,J12,E14:G14,F15:G15,H14:J16].Offset(,16*i).Interior.Color=0:Next

Produzione

Babomb

— Taylor Scott
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.