Lassen Sie uns einige Atari ST-Bomben zeichnen!

46

Einführung

Der Atari ST war von Mitte der 80er bis Anfang der 90er Jahre ein recht beliebter Personal Computer, der von einem Motorola 68000-Mikroprozessor angetrieben wurde. Auf diesem Computer bestand das Standardverhalten des Betriebssystems für nicht erfasste CPU-Ausnahmen darin, eine Reihe von Bomben auf dem Bildschirm anzuzeigen, wie in der folgenden Abbildung dargestellt:

Reihe von Bomben

Quelle: https://commons.wikimedia.org/wiki/File:Row_of_bombs.png
NB: Je nach Betriebssystemversion können die Bombengrafiken leicht variieren. Aber nehmen wir diesen als Referenz.

Die Anzahl der Bomben hängt vom Ausnahmevektor ab. Die häufigsten sind:

  • ($ 008) Busfehler: 2 Bomben
  • ($ 00c) Adressfehler: 3 Bomben
  • ($ 010) Illegale Anweisung: 4 Bomben

Tor

Ihr Ziel ist es, ein Programm oder eine Funktion zu schreiben, die eine ASCII-Grafik solcher Atari-ST-Bomben druckt oder ausgibt.

Eingang

Eine Ganzzahl, die die Anzahl der anzuzeigenden Bomben angibt. Ihr Code muss die gebräuchlichsten Werte unterstützen: 2, 3 und 4. Weniger und / oder mehr Bomben zu unterstützen ist in Ordnung, aber weder erforderlich noch von einem Bonus abhängig.

Ausgabe

Die Originalbombe besteht aus einer 16x16-Pixel-Kachel, die hier sowohl in ASCII- als auch in Binärdarstellung dargestellt ist:

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

Bei dieser Herausforderung muss jede ASCII-Bombe zum besseren Rendern auf das Doppelte ihrer ursprünglichen Breite gedehnt werden. Daher besteht es aus 16 Zeilen mit 32 Zeichen, wobei ##für "EIN" -Pixel zwei Leerzeichen für "AUS" -Pixel verwendet werden. Alle Bombenplättchen müssen nebeneinander liegen. Führende Leerzeichen sind verboten. Nachgestellte Leerzeichen sind ebenfalls verboten, mit Ausnahme derjenigen, die tatsächlich Teil des Bombenplättchens sind (dh die 31. und 32. Spalte), die vorhanden sein müssen . Sie dürfen nicht mehr als einen führenden Zeilenumbruch und nicht mehr als einen nachfolgenden Zeilenumbruch einfügen.

Beispiel

Nachfolgend finden Sie die Referenzausgabe für zwei Bomben, bei denen obligatorische Zeilenumbrüche als \nund tolerierte zusätzliche Zeilenumbrüche als gekennzeichnet sind (\n):

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

(Natürlich können auch andere Zeilenumbruchformate wie \roder \r\nverwendet werden.)

Regeln

Das ist Code-Golf, also gewinnt die kürzeste Antwort in Bytes. Standardlücken sind verboten.

code-golf  ascii-art  kolmogorov-complexity 
— Arnauld
quelle
Ich stelle fest, dass Sie nicht-ASCII-artige Formen ausgeschlossen haben, sodass eine Atari ST-Maschinencodefunktion, die mit der richtigen Anzahl von Bomben abstürzt, nicht zählt. (Die Bombe ist nicht in der Schrift enthalten, aber der Atari ST enthält Spaß- / Osterei-Glyphen in seinem ursprünglichen Zeichensatz, einschließlich der Zeichen 28–31, die aus 4 Teilen bestehen und das Bild von JR "Bob" Dobbs aus der satirischen Kirche bilden die SubGenius ich erinnere mich an ein Programm zu schreiben , die sie mit dem Text-Zeichensystemaufrufen :) diese 4 Glyphen wahllos Bildschirmpositionen, als sehr früh Übung spammed.
— Peter Cordes
1
@PeterCordes - Richtig, es muss ASCII sein. Sie können jedoch die Bombengrafiken aus dem ST-ROM lesen, da es keine Regel gibt, die Sie daran hindert. (Erwähnen Sie einfach die TOS-Version, an der dies funktionieren soll.)
— Arnauld,
1
Oh WOW, das weckt Erinnerungen. Mein erster Computer war ein Atari ST. Ich erinnere mich mit Furcht an diese Bomben.
— Rod
Nebenbei: "Die Anzahl der Bomben hängt vom Ausnahmevektor ab" - was sagen ?! Gibt es einen Grund, warum sie den tatsächlichen Code / Fehler nicht ausgeben konnten? (Hatte noch nie eine ST, ich bin aus dem Amiga-Lager ... "Guru-Meditation" und all das.)
— MrWhite

Antworten:

20

Jelly , 43 44 Bytes

+1 Byte - habe vergessen, die Zeichen zu verdoppeln (nicht, dass es jemand bemerkt hätte!)

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

TryItOnline

Wie?

Die Vorbereitung bestand darin, die Daten als Lauflängencodierung des Originalbilds zu komprimieren:

  • Zählen Sie die Länge jedes Laufs von 1s (Leerzeichen) oder 0s (Raute) im Bild und ignorieren Sie dabei die neuen Zeilen. Sie erhalten eine Liste [4,2,11,1,1,...]:;
  • Subtrahiere eins von jeder Zahl - dies ergibt einen Bereich von [0,15];
  • Behandle dies als eine Zahl zur Basis 16 (zähle die Werte auf v, wobei der Index iumgekehrt ist und summiere 16**i*v= 19468823747267181273462257760938030726282593096816512166437);
  • Konvertiere dies in base-250 [5,119,249,42,...]:;
  • Abbildung in Jellys Codepage als Index: ¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P

Jetzt wertet der Code diese Zahl aus, ordnet die Zeichen 1s und 0s Leerzeichen und Hash-Zeichen * zu, verdoppelt sie jeweils, teilt sie in Zeilen auf und wiederholt sie entsprechend oft.
* Tatsächlich wird die Implementierung modulo 2 ausgeführt, um Bytes zu sparen. Leerzeichen sind also ungerade und Hashes sind gerade:

“¥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
quelle
19

05AB1E , 57 55 53 50 Bytes

Verwendet CP-1252- Codierung.

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

Probieren Sie es online!

Erläuterung

Da das Ausgabebild nur aus 2 Zeichen besteht, können wir es als Binärzahl darstellen.
Wir können Zeilenumbrüche ignorieren, da jede Zeile die gleiche Länge hat.
Wir können das letzte Zeichen jeder Zeile ignorieren, da es für alle Zeilen gleich ist.
Wir verwenden das dünnere Bild, da es weniger Platz beansprucht und wir jedes Zeichen später leicht duplizieren können.

Mit 1 als Zeichen für Leerzeichen und 0 als Zeichen für # erhalten wir die Binärzahl:

111100111111111101011011111111111111101111111011011110111111110111000001111111111000001111111100000000011111000000000001111000000000001110000000000000110000000010000111000000010001111000000100001111100000000011111110000000111111111100011111

Wir konvertieren dies dann in Basis 10 und komprimieren es dann auf Basis 214, die maximale Basis in 05AB1E. Das Ergebnis ist:

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

Das Fleisch des Programms besteht dann aus:

<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
quelle
12

Pyth, 57 56 54 53 51 50 Bytes

Der Code enthält nicht druckbare Zeichen. Hier ist also ein umkehrbarer xxdHexdump.

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

Probieren Sie es online aus.

— PurkkaKoodari
quelle
11

JavaScript (ES6), 159 154 140 136 Bytes

Dank @Hedi und @Arnauld wurden viele Bytes gespeichert

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

Das sind 104 Zeichen, aber (leider) 136 UTF-8 Bytes. Die Zeichenfolge wurde mit diesem Snippet generiert:

Code-Snippet anzeigen

Verwenden .replacestatt [...string].mapist gleich lang:

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

Wie es funktioniert

Da jede Zeile der Rohdaten als 16-Bit-Zahl dargestellt werden kann, können wir die gesamte Datei in einer 16-Zeichen-Zeichenfolge speichern. Der Komprimierungsalgorithmus nimmt jede binäre Zeile, dreht sie um und kehrt sie um (da jede Zeile im Original mit einer 0 endet , beginnt jede Zeile in der modifizierten Version jetzt mit einer 1 ), wandelt sie dann in ein Zeichen um und verkettet die resultierenden Zeichen .

Um es zu dekomprimieren, müssen wir den Zeichencode extrahieren und seine Binärdarstellung in eine Folge von Hashes und Leerzeichen umwandeln. Dies kann mit einer rekursiven Funktion wie folgt geschehen:

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

fwiederholt das letzte Bit von q, wählt zwei Leerzeichen aus, wenn es 1 oder zwei Hashes sind, wenn es 0 ist, und verkettet dies mit dem Ergebnis der Ausführung fim Rest von q. Dies wird ausgeführt x.charCodeAt(), indem der Zeichencode in die richtige Folge von Leerzeichen und Hashes umgewandelt wird.

(Früher gab es hier viel mehr Drama, aber die 4-Byte-Spartechnik hat das alles beseitigt.)

Danach können wir die Zeichenfolge einfach wiederholen nund eine neue Zeile hinzufügen. Dies ist die kürzeste Dekomprimierungsmethode, die ich gefunden habe. Sie können jedoch auch kürzere Methoden vorschlagen.

Andere Versuche, die Zeichenfolge zu komprimieren:

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

Das erste von diesen ist 153 Bytes, also kommt keines von ihnen irgendwo in der Nähe von 136 ...

— ETHproductions
quelle
Könnte ein paar Bytes speichern mit +x?'##':' 'anstelle von" #"[x].repeat(2)
— Hedi
@Hedi danke, ich wusste, dass es so eine Möglichkeit gibt, Golf zu spielen.
— ETHproductions
2
Könnten Sie die Bits direkt testen, x.charCodeAt()anstatt sie in Binärdateien umzuwandeln? (Ich denke, das würde ungefähr 8 Bytes einsparen.)
— Arnauld
2
Ihr Komprimierungsalgorithmus klingt fast kryptografisch .
— Justin
1
@ Justin Damn, ich wollte das gerade kommentieren.
— user253751
10

MS-DOS-COM-Datei 84 Byte

OKAY. Nur zum Spaß, weil ich die 50 Bytes nicht schlagen kann ...

Versucht unter DOSbox sowie unter MS-DOS 6.22 in einer virtuellen Maschine.

Unter DOSbox funktioniert das Programm einwandfrei, unter echtem MS-DOS wird die Ausgabe jedoch nicht korrekt angezeigt, da für DOS CR-LF anstelle von LF am Zeilenende erforderlich ist.

(Die Ausgabe ist jedoch korrekt.)

Eine 88-Byte-Variante würde CR-LF am Ende der Zeile verwenden.

Hier ist die Datei:

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

Der Assembler-Code (in AT & T-Syntax) sieht folgendermaßen aus:

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

--- Bearbeiten ---

Ich habe vergessen zu erwähnen: Das Programm muss mit der folgenden Kommandozeile gestartet werden:

Name der COM-Datei + genau ein Leerzeichen + Anzahl der Bomben (1-9)

— Martin Rosenau
quelle
1
Nett. Wir haben noch keine 68000-Antwort, aber diese kommt näher. :-)
— Arnauld
objdump -dwDie Ausgabe ist eine gute Möglichkeit, die rohe Binärdatei anzuzeigen, da Sie sehen, welche Bytes zu welchen Befehlen gehören. Ich habe das für gcd und adler32 Antworten gemacht. (Sowie kommentierte Quellcode für die Menschen, um sich selbst zu versuchen.)
— Peter Cordes
8

Python, 223 179 Bytes

Zweiter Ansatz:

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

Probieren Sie es auf repl.it!

Anstatt direkt eine Liste von Zeichenfolgen zu erstellen, gibt es eine fest codierte hexadezimale Zeichenfolge, die indiziert und in eine binäre Zeichenfolge konvertiert wird. dann wird jede Binärziffer in entweder ' 'oder umgewandelt '#', was dupliziert und zusammengefügt wird ... usw.

Erste Ansatz:

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

Probieren Sie es auf repl.it!

Diese enthält eine hartcodierte Liste der Zeichenfolgen jeder Zeile (ohne nachfolgende Leerzeichen), die entweder durch ' 'oder durch mehrmaliges Duplizieren erstellt wurden '##'. Für jede dieser Zeichenfolgen werden Leerzeichen bis zu einer Länge von 32 Zeichen neingefügt , zweimal dupliziert und dann mit Zeilenumbrüchen verbunden.

— Hactar
quelle
Sie können ein Byte speichern, indem Sie zum Drucken eines nicht gerollten Generators wechseln, anstatt sich anzuschließen '\n'. Also 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))). Außerdem müssen Sie nicht die Bytes zählen, die erforderlich sind, um dem Lambda einen Namen zuzuweisen. Ihre Punktzahl kann also 176 sein.
— Morgan Thrapp
6

C 250 240 208 188 Bytes

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

Wechseln Sie zur Verwendung einer Funktion.

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

Testen Sie so. main(c,v)char**v; { f(atoi(v[1])); } 

a.exe 2
        ####                            ####                        
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                    
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
— Cleblanc
quelle
Sie können einige Bytes sparen, indem Sie die Dezimalzahlen dieser Hexadezimalzahlen verwenden, um die zu verlieren 0x.
— Kupfer
@Copper Danke, ich habe es geschafft, einige Bytes zu rasieren, auch mit Write anstelle von Putchar.
— Cleblanc
6

/// , 539 532 + nr. von Bomben Bytes

Die erste Antwort zeigt 4 Bomben. Die letzten vier Einsen können durch eine beliebige unäre Darstellung der Anzahl der zu druckenden Bomben ersetzt werden (11 für 2, 111 für 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

Probieren Sie es online!

Wenn die Eingabe dezimal sein muss, hat die folgende 555 548 Byte (wobei die letzte Ziffer in 1, 2, 3 oder 4 geändert werden kann):

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

Probieren Sie es online!

Die wichtigsten Teile des Codes sind:
| bedeutet //
ABCDEFGHIJKLMNOP bedeutet jede Zeile der Bombe bzw.
S bedeutet 2 Leerzeichen
s bedeutet 4 Leerzeichen
* bedeutet 6 Leerzeichen
q bedeutet 8 Leerzeichen
T
bedeutet ## ( 2) t bedeutet #### (4)
^ bedeutet ##### # (6)
r bedeutet ######## (8)
& ################# (16) Der
größte Teil des Codes stellt sicher, dass die Bomben gedruckt werden Seite an Seite, nicht übereinander.

— Boboquack
quelle
5

CJam , 66 Bytes

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

Probieren Sie es online! (Beachten Sie, dass der Code einige nicht druckbare Zeichen enthält.)

Die Bombe wird als Zahl in Binärform codiert, wobei 1 für Leerzeichen verwendet wird (das führende Leerzeichen als 1 stellt sicher, dass die binären Darstellungen nicht aufgefüllt werden müssen), transponiert und dann in Base-136 in String konvertiert (was den kürzesten String ergab) ohne breite Zeichen). Diese Schritte können hier gespielt werden .

Diese Antwort kehrt dann die Codierung um. Der Haupttrick besteht darin, die Bombe vor dem Transponieren zu wiederholen und so jede Zeile der Bombe auf einmal zu verketten. Die Zeichen in jeder Zeile können dann verdoppelt werden, wobei für die endgültige Ausgabe neue Zeilen eingefügt werden.

— Linus
quelle
5

PHP, 138 104 + 32 = 136 Bytes

Ich hätte nie gedacht, dass filedas binär sicher ist. Ich wünschte nur, ich hätte einen interessanteren Weg gefunden, um die Daten zu speichern. aber nichts, was ich versuchte, schlug rohe Binärdateien.

foreach(unpack("v*",file(b)[0])as$v)echo"
",str_repeat(strtr(sprintf("%016b",$v),["  ","##"]),$argv[1]);
  • Lese binäre Daten aus einer Datei, entpacke vom Little Endian 16bit in ein Array von int
  • Array durchschleifen: 16-stellige Binärzahl in Zeichenfolge ausgeben , durch 02 Leerzeichen ersetzen , 1mit ##,
    Wiederholungszeiten $argv[1], Ergebnis + Zeilenumbruch ausgeben

renn mit -r

Binärdaten in Datei b:

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

Code zum Generieren der Datei:

$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
quelle
2
Sie können 2 Bytes einsparen, indem Sie einen führenden Zeilenumbruch anstelle eines nachfolgenden verwenden und daher kein Leerzeichen nach dem Echo verwenden und einen tatsächlichen Zeilenumbruch anstelle des \n.
— User59178
@ user59178 Ich weiß. bitte nicht so ausführlich.
— Titus
5

MATL , 64 63 60 59 58 Bytes

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

Probieren Sie es online!

Erläuterung

Der Code verwendet eine vorkomprimierte Version der 16 × 16-Binärmatrix. Die Vorkomprimierung (nicht Teil des Programms) umfasste zwei Schritte:

  1. Lauflängencodierung der gelesenen Matrix in der Reihenfolge der Zeilenschwerpunkte (zuerst quer, dann runter).
  2. Die resultierenden Lauflängen reichen von 1 bis 16, so dass der Vektor der Lauflängen minus 1 von der Basis 16 zur Basis 94 konvertiert wurde (um alle druckbaren ASCII-Codes mit Ausnahme von einfachen Anführungszeichen zu verwenden, die nicht verwendet werden, weil sie maskiert werden müssten).

Die komprimierte Zeichenfolge

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

wird von Basis 94 auf Basis 16 dekomprimiert:

                                   F16Za

Der erhaltene Vektor der Lauflängen plus 1 wird mit 2 multipliziert:

                                        QE

um das horizontale Strecken durchzuführen.

Der Vektor der Lauflängen enthält 49 Werte. Die ursprünglichen Zahlen, die mit diesen Längen wiederholt werden sollen, sollten [0 1 0 1 ... 0](49 Einträge) sein. Stattdessen ist es jedoch kürzer, den Vektor zu verwenden [1 2 ... 49], der dank modularer Indizierung gleichermaßen gültig ist. Die Lauflängendekodierung ist also

49:                                       Y"

Der erzeugte Vektor containis die Läufe von 1, 2, ... 49, für insgesamt 512 Einträge. Dies wird in eine 16 × 32-Matrix umgewandelt:

                                            32e!

und als modulare Indizes in die Zeichenfolge verwendet ' #', um eine einzelne Bombe zu produzieren:

                                                ' #'w)

Schließlich führt die horizontale Wiederholung um einen von der Eingabe vorgegebenen Faktor zum gewünschten Ergebnis:

                                                      liX"
— Luis Mendo
quelle
4

Python 2: 143 Bytes

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

Es ist bei Ideone

(Mir ist aufgefallen, dass die direkte Codierung der Originalbombe in Basis 36 für kürzeren Code in Python sorgt.)

Die Zeichenfolge wurde gebildet, indem Leerzeichen als 1s und Hashes als 0s behandelt und dann in Basis 36 konvertiert wurden. Das Programm konvertiert dann zurück in Binär und schneidet in Längen von 16 (mit einem Versatz von 2 für '0b' an der Vorderseite von Python binäre Zeichenkette), konvertiert in doppelte Leerzeichen und doppelte Hashes, fügt sie zusammen, wiederholt die Zeichenkettenzeiten nund druckt.

Zurück: Python 2, 169 166 163 Bytes

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

Es ist bei Ideone

Fast ein Port meiner Gelee-Antwort .

— Jonathan Allan
quelle
Ineffizient ist gut, wenn es kürzer ist. Nice +1
— ElPedro
4

Python 2.7, 144 141 Bytes

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

Die Bombe ist binär mit 1 für Leerzeichen geschrieben, die führende 1 macht das Auffüllen von Binärdarstellungen überflüssig. Die Bombe wird transponiert (ähnlich wie in meiner CJam-Antwort ) und in Basis 36 gespeichert.

Das Programm dekodiert die Bombe in Binärdaten und iteriert die Bits in Schritten von 16 effektiv nach der Transposition (was Bytes beim Schneiden einer bestimmten Zeile spart). Die resultierende Zeile wird verkettet, Bits werden durch double or ersetzt #und zu einer einzigen Zeichenfolge verbunden.

— Linus
quelle
1
Sie können die führende Null von Ihrer Basiszahl 36 entfernen.
— Jonathan Allan
@ JonathanAllan: Schöner Fang. Ich dachte, das wäre Oaus irgendeinem Grund ...
— Linus
4

C (GCC) , 216 204 183 165 134 Bytes

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

Probieren Sie es online!

Als eigenständiges Programm geschrieben ( 201 183 151 Bytes)

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

Probieren Sie es online!

Dieser Fehler tritt auf, wenn kein Befehlszeilenparameter angegeben wird.

— Ceilingcat
quelle
3

Batch, 415 Bytes

@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:#=##%

Hinweis: Die Zeile set s=endet in 5 Leerzeichen. Akzeptiert die Anzahl als Befehlszeilenparameter. Durchlaufen Sie einfach jede Zeile der Bombe (sehr leicht komprimiert durch Entfernen von Läufen mit 5 identischen Zeichen) und wiederholen Sie die Bombe so oft wie gewünscht, bevor Sie die einzelnen Zeichen endgültig duplizieren.

— Neil
quelle
3

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

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

Sah Hex nach der Nummernliste an, aber es schien nicht genug zu sparen, um die Mühe wert zu machen. Ich hatte gehofft, in der Lage zu sein, den Code nach unten zu spielen, schien aber mit diesem Ansatz so weit wie möglich gekommen zu sein. Weitere Hinweise dankbar erhalten.

BEARBEITEN

-1 durch Ändern e==1aufe>0 . Ich vergesse das immer.

-2 durch Ignorieren der Länge der Binärzeichenfolge, Voranstellen von 7 Nullen und Verwenden nur der letzten 16 Elemente. Funktioniert, da es nie mehr als 7 führende Nullen gibt.

-4 weil ich jetzt den zweiten Verweis auf die Variable b verloren habe, die ich verwenden kann bin(y)[2:] direkt in der Kartenfunktion verwenden kann, indem ich sie unter die magische 200 nehme :-)

-8 durch Verwendung der Slice-Zuweisung in der zweiten Liste. Heute Abend etwas Neues gelernt.

-3 mit Dank an @Jonathan

-2 mit c=d=([0]*7+map(int,bin(y)[2:]))[-16:]statt mitc=d;

-2 nochmal danke an @Jonathan

-24 danke an @Linus

Ausgabe

python bombs.py
2
        ####                            ####                    
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
— ElPedro
quelle
" #"[e>0]*2wird funktionieren
— Jonathan Allan
DOH! Wie habe ich das vermisst ??? Thanks @ Jonathan
— ElPedro
... die Klammern (...)können auch gehen (RE: nach meinem vorherigen Kommentar).
— Jonathan Allan
Sie können es bis 170 mitfor y in ...:print"".join(" #"[e>0]*2for e in(([0]*7+map(int,bin(y)[2:]))[-16:]))*z
— Jonathan Allan
@ Jonathan Nochmals vielen Dank. Es wird spät hier, also speichere ich diese Änderung für morgen, damit ich es nicht völlig vermassle.
— ElPedro
3

RProgN , 210 193 Bytes

Durch Umschalten von 0 = '' 1 = '##' auf 1 = '' 0 = '' wurden einige Bytes gespart. Dies bedeutet, dass keine zusätzlichen Nullen hinzugefügt werden müssen. Dies bedeutet auch, dass jetzt die B64-Zeichenfolge, die früher "MAFIA" sagte, dies nicht tut. Dies ist traurig.

'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

Erläuterung

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

Ziemlich lang. Das Expandieren, Drucken und dergleichen der komprimierten Zeichenfolge beträgt 105 Byte. Könnte ein bisschen mehr Golf sein, aber zumindest funktioniert es.

Die Eingabe erfolgt implizit auf dem Stapel, der Stapel wird implizit gedruckt.

Ausgabe

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

Versuch es!

<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>
Erweitern Sie das Snippet

— Ein Taco
quelle
3

PHP, 144 140 139 138 136 Bytes

Hinweis: Verwendet die Windows-1252-Codierung

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

Laufen Sie wie folgt:

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

Oder mit IBM-850-Codierung (135 Byte und schöneres Ergebnis):

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

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

Erläuterung

Dies macht keine binären Sachen und erfordert keine externe Datei.

Jede 16-Bit-Zahl wird umgekehrt und dann als eine Basis-36-Zahl codiert, die 0bei Bedarf mit einem führenden Zeichen aufgefüllt wird , sodass alle 16 Bits 3 Bytes ergeben. Verketten dieser Ergebnisse in 01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow. Der Code kehrt den Vorgang um, damit die Bomben korrekt gedruckt werden N.

Optimierungen

  • 4 Bytes mit nur einer For-Schleife gespart
  • Sie haben ein Byte gespeichert, indem Sie für jede Iteration ein einzelnes Zeichen gedruckt und den Zeichenfolgenindex anstelle des ternären Index verwendet haben
  • Ein Byte wurde gespeichert, indem an den Zeilengrenzen mit $jauf Null zurückgesetzt wurde %=. Dadurch werden Klammern entfernt
  • 2 Bytes mit gespeichert $argn
— aross
quelle
3

GCC C 129 Bytes

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 einer Zeile:

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

Laufen mit:

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

Kompilieren Sie die Quelle als ISO8859-x (ASCII).

NB óÿÿþÿoÜüðààÀÀ! ÀCàCðøþ? sollte die unsichtbaren ASCII-Codes enthalten, wurde jedoch aufgrund der Darstellung des Inhalts von StackExchange beschädigt. Unter dem Link ideaone finden Sie die richtige Testcodierung. Alternativ finden Sie den Original-ASCII-String unter: https://github.com/claydonkey/AtariBombs/blob/master/ISO8859_REPR2.txt

Erläuterung

Zuerst eine Umrechnung der hexadezimalen Darstellung von Bomben [f3 ff In der UTF-8-Version speichert der Compiler die Zeichenfolge als Wide Char Array (2 oder 4 Byte für jedes Zeichen zur Laufzeit, dies ist jedoch akademisch). Während UTF-8-Zeichen als 2-4 Byte gespeichert würden, liegen diese Werte alle innerhalb von ISO-8859-1 (ASCII) und erfordern daher nur 1 Byte. Es ist auch sicher, als ISO-8859-x gespeichert zu werden (es gibt keine 0x8_- oder 0x9_-Werte). Daher belegt der Text in ISO-8859 32 Byte und die Routine insgesamt 135 Byte.

(NB Wide Chars werden in Windows als 16-Bit-Integer und in Linux als 32-Bit-Integer gespeichert, aber auch dies ist für die jeweilige Aufgabe irrelevant.)

Vorsichtsmaßnahme: Es können nicht alle Zeichen angezeigt werden (die Steuerzeichen unter 0x20). Sie sind jedoch noch vorhanden. Die meisten Webseiten sind utf-8 / 8859/1253 ( https://w3techs.com/technologies/overview/character_encoding/all ), daher halte ich dies für legitim (das Verschieben aller Werte unter 0x20 zu druckbarem ASCII sollte dies beheben).

UTF-8

Hier ist die Version, die der ursprünglichen Veröffentlichung mit UTF-8-codierter Quelle näher kommt. Dies verbraucht 173 Bytes. Die Zeichenfolge selbst besteht aus 50 Byte der Quelle. Die Routine ist auch länger, da die ASCII-Bytes jetzt mit Auffüllungs-Nullen für die 16-Bit / 32-Bit-Wide-Zeichen gespeichert werden und statt wie oben beschrieben nach uint16_t verschoben werden müssen. Ich habe das durchgehalten, da es mit ideone verifiziert werden kann, das UTF-8-Codierung verwendet.

*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)?"  ":"##")));}

Laufen mit:

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

Wenn Sie den impliziten Wert in Ihrem Complier auf eine 16-Bit-Ganzzahl setzen können, können Sie die wchar_t-Typdeklaration des Wide Char weglassen. Ideone beschwert sich nicht und ich denke, es ist gut zu gehen.

Probiere es auf ideone aus

— Claydonkey
quelle
Beeindruckend. Welche Codierung wird verwendet?
— DJMcMayhem
Es ist auf MinGW GCC kompiliert, wo ein breites Zeichen ein uint16 ist. Daher ist die Codierung [16-Bit-Typ mit UTF-16-Unicode]. Ich denke jedoch, dass, da die Zeichen innerhalb von 0xFF (16 Bit) sind, sie ASCII erweitert werden. + Also nichts besonderes
— Claydonkey
Tut mir leid, ich habe ein bisschen mehr über die Codierung gelernt und kann mich geirrt haben, wenn sie als UTF-16 gespeichert wurde. Beziehen Sie sich bitte auf die überarbeitete Antwort.
— Claydonkey
2

Haskell, 155 Bytes

Als eine Funktion mit Typ 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]]

Das direkte Drucken an IO kostet 5 Bytes (oder 6, wenn wir lieber zurückkehren IO ()als 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
quelle
2

C 175 Bytes

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

verkettet jedes x mit sich selbst und lässt p überlaufen, um jede Zeile zu beenden.

ah, ich habe printf () geändert, um beim Golfen zu schreiben und das hat es kaputt gemacht. Testen Sie hier ideone.com/JtHInD
2

Java, 228 Bytes

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
quelle
1
Ich weiß, dass es ein Jahr her ist, aber Sie können es so spielen: 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 Bytes ) Abgesehen von der Verwendung von Java 8 Lambda habe ich mehr Bytes reduziert, indem ich Folgendes x=16geändert habe: die Position von (und geändert whilezu for); 2x ==0bis <1; Rückgabe sstatt Drucken (Importe sind auch Teil der Byteanzahl übrigens); --x>=0zu x-->0. Trotzdem, tolle Antwort, also +1!
— Kevin Cruijssen
@ KevinCruijssen Danke (erwägen Sie, dies als eigene Antwort zu veröffentlichen). Ich bin hier bei Codegolf nicht sooo aktiv und daher nicht sicher, was die Regeln angeht, aber ich denke, dass in den meisten Fällen nur das Zählen der Funktionsbytes (und das Ignorieren der Importe) zulässig ist.
— Marco13
Es ist ein bisschen zu ähnlich, um als getrennte Antwort zu posten, aber ich kann verstehen, ob Sie Ihre Antwort von vor über einem Jahr nicht bearbeiten möchten. :) Ich lasse es einfach im Kommentar. Und ich befürchte, dass Importe tatsächlich zur Byteanzahl zählen.
— Kevin Cruijssen
2

J 89 Bytes

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

Codiert die Zeichenfolge als Basis-95-Zahl und erhöht jede Ziffer um 32 und repräsentiert sie dann durch eine ASCII-Zeichenfolge.

Erläuterung

Dies setzt sich aus zwei Hauptteilen zusammen. Da ist der Bau der Bombe und die tatsächliche Wiederholung. Nennen wir für den Moment die Bombe als b. Dann sieht der Code so aus:

|:@;@#&(b)

Bei einem Aufruf mit Eingabe kentspricht dies:

|: ; (k#b)

b ist eine Boxbombe, also k#b macht also kWiederholungen von b, ;glättet sie vertikal und |:transponiert das Ergebnis. (Die Bombe bist selbst transponiert aufgebaut.)

Hier ist die Bombe:

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

Die folgende Zeichenfolge ist eine Base-95-codierte Zeichenfolge mit einem Offset von 32, sodass alle Zeichen in den ASCII-Bereich fallen und glücklicherweise keine Escape-Zeichen vorhanden sind '. 3 u:Ruft die Zeichencodes der Zeichenfolge ab, 32x-~macht jede Zahl zu einer erweiterten xZahl und subtrahiert 32sie. 95#.konvertiert in eine Base-95-Zahl und 2#.invkonvertiert sie in ein binäres Ziffernfeld. Ich habe einen Anführer hinzugefügt1 habe der Binärdatei , um sie zu einer festen Zahl zu machen, also ziehe ich sie mit ab }.. Ich gestalte das Array in eine 16x16-Tabelle 16 16$und transponiere es dann mit |:. (Mögliches Golfspiel für später: transponieren Sie die wörtlich codierte Zeichenfolge.) 2#Dupliziert jedes Zeichen in der Breite. Wir haben eine Tabelle mit0 s und 1s.' #'{~Karten0s zu ' 'und 1zu '#'. So bleiben wir mit unserer Bombe zurück.

Testfall

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

BaCon , 229 227 195 Bytes

Ein Beitrag in BASIC der Nostalgie zuliebe. Die Variable 'a' bestimmt die Anzahl der Bomben.

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}

Ausgabe :

        ####                            ####                    
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
— Peter
quelle
2

Haskell, 191 181 Bytes

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
quelle
2

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

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

Hierbei wird die Bombenbitmap aus dem TOS-ROM verwendet, die sich geringfügig von der in Frage kommenden unterscheidet. Bei anderen Versionen von TOS müssen Sie die Adresse anpassen, auf die von verwiesen wird*a . Beachten Sie, dass einige Emulator-ROMs die Bomben-Bitmap nicht enthalten!

Wenn Sie kein Befehlszeilenargument angeben, werden möglicherweise mehrere hochauflösende Bitmap-Bomben angezeigt :-)

— Ceilingcat
quelle
1

C ++ 11, 252 Bytes

#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 Bytes

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

Bildschirmfoto
(Screenshot der Version ohne doppelte Zeichen)
SB hat eine quadratische Schrift, daher sieht das Verdoppeln der Zeichen schlecht aus (und passt nicht auf den Bildschirm).
Nicht-ASCII-Zeichen wurden durch x's' ersetzt.
Hex-Werte: 0008,0002,0610,1F8A,3FC1,7FC1,7FF2,FFF4,FFF8,EFF0,73F0,7FC0,3FC0,1F80,0600
Da SB Dateien in UTF-8 speichert, zählen einige davon als 2 oder 3 Bytes.

— 12Me21
quelle
@ Arnauld Ich weiß nicht viel über SmileBASIC, aber da es eine Schleife FOR K=1TO Nmit gibt INPUT N, denke ich, dass sie die Anzahl der Bomben anzeigt, die in der Eingabe angegeben sind. Ich muss jedoch sagen, dass trotz der quadratischen Schrift die Zeichen meiner Meinung nach immer noch verdoppelt werden sollten, um die Anforderungen zu erfüllen (um einen Vorteil gegenüber anderen Antworten zu vermeiden). Sie könnten die aktuelle Version beibehalten, um eine ansprechendere Lösung zu erhalten, aber ich denke, Sie sollten trotzdem eine korrekte Lösung hinzufügen. Sobald Sie dies hinzufügen, werde ich mich für den kreativen Einsatz der UTF-8-Zeichen aussprechen!
— HyperNeutrino
@AlexL. Ja, mein Kommentar war vor dem Code-Update.
— Arnauld
1

Ruby 2.x (Lambda) - 157 Byte

Kann wahrscheinlich weiter golfen werden, aber mir gefällt diese Version:

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

Ähnliche Idee wie die Python-Version (en): Teilen Sie die hexadezimal codierten Bomben in Abschnitte mit 4 Zeichen, konvertieren Sie sie in Binärdateien, übersetzen Sie sie 1in #und 0nach , verdoppeln Sie jedes Zeichen und drucken Sie das resultierende Array.

Beachten Sie, dass Puts zum Drucken des Arrays verwendet wird. Dadurch wird das Array eine Zeile pro Element ausgedruckt.

— Nerketur Kamachi
quelle
1

Excel VBA, 204 Bytes

Anonyme VBE- [A1]Direktfensterfunktion , die Eingaben aus dem Bereich übernimmt und an das ActiveSheet-Objekt ausgibt

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

Ausgabe

Babomb

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