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:
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 \n
und 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 \r
oder \r\n
verwendet werden.)
Regeln
Das ist Code-Golf, also gewinnt die kürzeste Antwort in Bytes. Standardlücken sind verboten.
Antworten:
Jelly ,
4344 Bytes+1 Byte - habe vergessen, die Zeichen zu verdoppeln (nicht, dass es jemand bemerkt hätte!)
TryItOnline
Wie?
Die Vorbereitung bestand darin, die Daten als Lauflängencodierung des Originalbilds zu komprimieren:
1
s (Leerzeichen) oder0
s (Raute) im Bild und ignorieren Sie dabei die neuen Zeilen. Sie erhalten eine Liste[4,2,11,1,1,...]
:;[0,15]
;v
, wobei der Indexi
umgekehrt ist und summiere16**i*v
=19468823747267181273462257760938030726282593096816512166437
);[5,119,249,42,...]
:;¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P
Jetzt wertet der Code diese Zahl aus, ordnet die Zeichen
1
s und0
s 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:
quelle
05AB1E ,
57555350 BytesVerwendet CP-1252- Codierung.
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:
Das Fleisch des Programms besteht dann aus:
quelle
Pyth,
575654535150 BytesDer Code enthält nicht druckbare Zeichen. Hier ist also ein umkehrbarer
xxd
Hexdump.Probieren Sie es online aus.
quelle
JavaScript (ES6),
159154140136 BytesDank @Hedi und @Arnauld wurden viele Bytes gespeichert
Das sind 104 Zeichen, aber (leider) 136 UTF-8 Bytes. Die Zeichenfolge wurde mit diesem Snippet generiert:
Code-Snippet anzeigen
Verwenden
.replace
statt[...string].map
ist gleich lang: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
wiederholt das letzte Bit vonq
, wählt zwei Leerzeichen aus, wenn es 1 oder zwei Hashes sind, wenn es 0 ist, und verkettet dies mit dem Ergebnis der Ausführungf
im Rest vonq
. Dies wird ausgeführtx.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
n
und 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:
Das erste von diesen ist 153 Bytes, also kommt keines von ihnen irgendwo in der Nähe von 136 ...
quelle
+x?'##':' '
anstelle von" #"[x].repeat(2)
x.charCodeAt()
anstatt sie in Binärdateien umzuwandeln? (Ich denke, das würde ungefähr 8 Bytes einsparen.)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:
Der Assembler-Code (in AT & T-Syntax) sieht folgendermaßen aus:
--- 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)
quelle
objdump -dw
Die 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.)Python,
223179 BytesZweiter Ansatz:
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:
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 Zeichenn
eingefügt , zweimal dupliziert und dann mit Zeilenumbrüchen verbunden.quelle
'\n'
. Alsolambda 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.C
250240208188 BytesWechseln Sie zur Verwendung einer Funktion.
Testen Sie so.
main(c,v)char**v; { f(atoi(v[1])); }
quelle
0x
./// ,
539532 + nr. von Bomben BytesDie 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).
Probieren Sie es online!
Wenn die Eingabe dezimal sein muss, hat die folgende
555548 Byte (wobei die letzte Ziffer in 1, 2, 3 oder 4 geändert werden kann):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.
quelle
CJam , 66 Bytes
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.
quelle
PHP,
138104 + 32 = 136 BytesIch hätte nie gedacht, dass
file
das 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.0
2 Leerzeichen ersetzen ,1
mit##
,Wiederholungszeiten
$argv[1]
, Ergebnis + Zeilenumbruch ausgebenrenn mit
-r
Binärdaten in Datei
b
:Code zum Generieren der Datei:
quelle
\n
.MATL ,
6463605958 BytesProbieren 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:
Die komprimierte Zeichenfolge
wird von Basis 94 auf Basis 16 dekomprimiert:
Der erhaltene Vektor der Lauflängen plus 1 wird mit 2 multipliziert:
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 alsoDer erzeugte Vektor containis die Läufe von
1
,2
, ...49
, für insgesamt 512 Einträge. Dies wird in eine 16 × 32-Matrix umgewandelt:und als modulare Indizes in die Zeichenfolge verwendet
' #'
, um eine einzelne Bombe zu produzieren:Schließlich führt die horizontale Wiederholung um einen von der Eingabe vorgegebenen Faktor zum gewünschten Ergebnis:
quelle
Python 2: 143 Bytes
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
n
und druckt.Zurück: Python 2,
169 166163 BytesEs ist bei Ideone
Fast ein Port meiner Gelee-Antwort .
quelle
Python 2.7,
144141 BytesDie 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.quelle
O
aus irgendeinem Grund ...C (GCC) ,
216 204 183 165134 BytesProbieren Sie es online!
Als eigenständiges Programm geschrieben (
201 183151 Bytes)Probieren Sie es online!
Dieser Fehler tritt auf, wenn kein Befehlszeilenparameter angegeben wird.
quelle
Batch, 415 Bytes
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.quelle
Python 2,
206205203199191188186184160 BytesSah 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==1
aufe>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
quelle
" #"[e>0]*2
wird funktionieren(...)
können auch gehen (RE: nach meinem vorherigen Kommentar).for y in ...:print"".join(" #"[e>0]*2for e in(([0]*7+map(int,bin(y)[2:]))[-16:]))*z
RProgN ,
210193 BytesDurch 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.
Erläuterung
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!
quelle
PHP,
144140139138136 BytesHinweis: Verwendet die Windows-1252-Codierung
Laufen Sie wie folgt:
Oder mit IBM-850-Codierung (135 Byte und schöneres Ergebnis):
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
0
bei Bedarf mit einem führenden Zeichen aufgefüllt wird , sodass alle 16 Bits 3 Bytes ergeben. Verketten dieser Ergebnisse in01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow
. Der Code kehrt den Vorgang um, damit die Bomben korrekt gedruckt werdenN
.Optimierungen
$j
auf Null zurückgesetzt wurde%=
. Dadurch werden Klammern entfernt$argn
quelle
GCC C 129 Bytes
ISO8859 / ASCII
In einer Zeile:
Laufen mit:
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.
Laufen mit:
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
quelle
Haskell, 155 Bytes
Als eine Funktion mit Typ
Int -> String
:Das direkte Drucken an IO kostet 5 Bytes (oder 6, wenn wir lieber zurückkehren
IO ()
alsIO [()]
):quelle
C 175 Bytes
verkettet jedes x mit sich selbst und lässt p überlaufen, um jede Zeile zu beenden.
quelle
Java, 228 Bytes
quelle
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 Folgendesx=16
geändert habe: die Position von (und geändertwhile
zufor
); 2x==0
bis<1
; Rückgabes
statt Drucken (Importe sind auch Teil der Byteanzahl übrigens);--x>=0
zux-->0
. Trotzdem, tolle Antwort, also +1!J 89 Bytes
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:Bei einem Aufruf mit Eingabe
k
entspricht dies:b
ist eine Boxbombe, alsok#b
macht alsok
Wiederholungen vonb
,;
glättet sie vertikal und|:
transponiert das Ergebnis. (Die Bombeb
ist selbst transponiert aufgebaut.)Hier ist die Bombe:
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 erweitertenx
Zahl und subtrahiert32
sie.95#.
konvertiert in eine Base-95-Zahl und2#.inv
konvertiert 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-Tabelle16 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 und1
s.' #'{~
Karten0
s zu' '
und1
zu'#'
. So bleiben wir mit unserer Bombe zurück.Testfall
quelle
BaCon ,
229227195 BytesEin Beitrag in BASIC der Nostalgie zuliebe. Die Variable 'a' bestimmt die Anzahl der Bomben.
Ausgabe :
quelle
Haskell,
191181 Bytesquelle
C (Atari TOS 2.06 US),
129 124 117113 BytesHierbei 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 :-)
quelle
C ++ 11, 252 Bytes
quelle
SmileBASIC, 127 Bytes
(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.
quelle
FOR K=1TO N
mit gibtINPUT 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!Ruby 2.x (Lambda) - 157 Byte
Kann wahrscheinlich weiter golfen werden, aber mir gefällt diese Version:
Ä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
1
in#
und0
nach, 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.
quelle
Excel VBA, 204 Bytes
Anonyme VBE-
[A1]
Direktfensterfunktion , die Eingaben aus dem Bereich übernimmt und an das ActiveSheet-Objekt ausgibtAusgabe
quelle