Als ich aufwuchs, war mein erstes Konsolenspielsystem ein Atari 2600, und ich werde immer eine Vorliebe für einige der Spiele haben, die ich als Kind so genossen habe. Viele der Grafiken sind immer noch einprägsam, vielleicht sogar ikonisch.

Es stellt sich heraus, dass diese Sprites sehr vereinfachte Bitmaps mit einer Breite von 8 Pixeln und variabler Höhe sind, wobei die binäre Darstellung die Anordnung der Pixel ist.

Zum Beispiel würden die hexadezimalen Bytes 0x18, 0x24, 0x18 einen groben Kreis wie folgt zeichnen:

0x18: 00011000
0x24: 00100100
0x18: 00011000

Da eine Breite von 8 Pixeln relativ kleine Grafiken erzeugt (selbst nach Atari 2600-Standards), war es üblich, entweder die Höhe oder die Breite oder beides zu verdoppeln oder zu vervierfachen, um eine größere (wenn auch blockartigere und verzerrtere) Version desselben Bildes zu erzeugen. Sie werden normalerweise sowohl für Sprites als auch für Spielfelder vertikal oder horizontal gespiegelt. Das Spiel Combat ist ein gutes Beispiel dafür.

Die Herausforderung besteht darin, Code zu schreiben, um diese Sprites als "Grafiken" in ASCII-Form anzuzeigen, einschließlich der Möglichkeit, sie vertikal, horizontal oder beides zu strecken oder zu spiegeln. Dies muss in Form eines vollständigen Programms oder einer aufrufbaren Funktion erfolgen.

Eingang:

• Ein Array von Bytes, die jeweils die horizontalen Bits für diese Zeile darstellen.
• Ein ganzzahliger Wert ungleich Null für jede Richtung, horizontal und vertikal, der den Skalierungsfaktor für diese Dimension darstellt.
• Ein negativer Wert gibt an, dass die Bemaßung auch entlang ihrer Achse gespiegelt werden soll.

Ausgabe:

• ASCII-Darstellung nach STDOUT oder einer durch Zeilenumbrüche getrennten Zeichenfolge, wobei ein Leerzeichen für schwarze (0) Pixel und ein beliebiges druckbares Zeichen ohne Leerzeichen für weiße (1) Pixel verwendet wird.

Testdaten:

bmp1 = [ 0x06, 0x0F, 0xF3, 0xFE, 0x0E, 0x04, 0x04, 0x1E, 0x3F, 0x7F, 0xE3, 0xC3, 0xC3, 0xC7, 0xFF, 0x3C, 0x08, 0x8F, 0xE1, 0x3F ]
bmp2 = [ 0x07, 0xFD, 0xA7 ]
bmp3 = [ 0x00, 0x8E, 0x84, 0xFF, 0xFF, 0x04, 0x0E, 0x00 ]
bmp4 = [ 0x00, 0xFC, 0xFC, 0x38, 0x3F, 0x38, 0xFC, 0xFC]

Hinweis: Die obigen Beispiele für Eingabearrays von Bytes sind hexadezimal angegeben. Wenn Ihre Plattform keine Hex-Literale für die Bytedarstellung akzeptiert, können Sie diese in ein natives byteäquivalentes Literal konvertieren.

Beispielausgabe:

f( bmp1, 1, 1 ) =>
--------
     XX 
    XXXX
XXXX  XX
XXXXXXX 
    XXX 
     X  
     X  
   XXXX 
  XXXXXX
 XXXXXXX
XXX   XX
XX    XX
XX    XX
XX   XXX
XXXXXXXX
  XXXX  
    X   
X   XXXX
XXX    X
  XXXXXX
--------

f( bmp1, -2, 1 ) =>
----------------
  XXXX          
XXXXXXXX        
XXXX    XXXXXXXX
  XXXXXXXXXXXXXX
  XXXXXX        
    XX          
    XX          
  XXXXXXXX      
XXXXXXXXXXXX    
XXXXXXXXXXXXXX  
XXXX      XXXXXX
XXXX        XXXX
XXXX        XXXX
XXXXXX      XXXX
XXXXXXXXXXXXXXXX
    XXXXXXXX    
      XX        
XXXXXXXX      XX
XX        XXXXXX
XXXXXXXXXXXX    
----------------

f( bmp2, 1, 2 ) =>
--------
     XXX
     XXX
XXXXXX X
XXXXXX X
X X  XXX
X X  XXX
--------

f( bmp2, 2, 1 ) =>
----------------
          XXXXXX
XXXXXXXXXXXX  XX
XX  XX    XXXXXX
----------------

f( bmp2, -2, -2 ) =>
----------------
XXXXXX    XX  XX
XXXXXX    XX  XX
XX  XXXXXXXXXXXX
XX  XXXXXXXXXXXX
XXXXXX          
XXXXXX          
----------------

f( bmp3, 1, -1 ) =>
--------

    XXX 
     X  
XXXXXXXX
XXXXXXXX
X    X  
X   XXX 

--------

f( bmp3, 3, 3 ) =>
------------------------



XXX         XXXXXXXXX   
XXX         XXXXXXXXX   
XXX         XXXXXXXXX   
XXX            XXX      
XXX            XXX      
XXX            XXX      
XXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXX
               XXX      
               XXX      
               XXX      
            XXXXXXXXX   
            XXXXXXXXX   
            XXXXXXXXX   



------------------------

f( bmp4, -1, -1 ) =>
--------
  XXXXXX
  XXXXXX
   XXX  
XXXXXX  
   XXX  
  XXXXXX
  XXXXXX

--------

f( bmp4, 4, 2 ) =>
--------------------------------


XXXXXXXXXXXXXXXXXXXXXXXX        
XXXXXXXXXXXXXXXXXXXXXXXX        
XXXXXXXXXXXXXXXXXXXXXXXX        
XXXXXXXXXXXXXXXXXXXXXXXX        
        XXXXXXXXXXXX            
        XXXXXXXXXXXX            
        XXXXXXXXXXXXXXXXXXXXXXXX
        XXXXXXXXXXXXXXXXXXXXXXXX
        XXXXXXXXXXXX            
        XXXXXXXXXXXX            
XXXXXXXXXXXXXXXXXXXXXXXX        
XXXXXXXXXXXXXXXXXXXXXXXX        
XXXXXXXXXXXXXXXXXXXXXXXX        
XXXXXXXXXXXXXXXXXXXXXXXX        
--------------------------------

Hinweis: Die horizontalen Linien oben und unten zeigen den Anfang und das Ende der Ausgabe. Sie werden in der Ausgabe nicht benötigt, es werden jedoch leere Zeilen (dargestellt durch alle Nullen / Leerzeichen) am Anfang und / oder Ende benötigt, wie gezeigt.

Anmerkung 2: Diese Test-Bitmaps wurden von Spiel-Screenshots inspiriert und neu gezeichnet / codiert, die in Wikipedia als "fair use" gekennzeichnet sind.

Gewinnkriterien

• Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes pro Sprache.
• Standard Lücken sind verboten.

Python 2 , 117 Bytes

def f(m,w,h):
 for r in m[::cmp(h,0)]:print(''.join(' X'[1<<i&r>0]*abs(w)for i in range(8)[::cmp(0,w)])+'\n')*abs(h),

Probieren Sie es online!

05AB1E , 27 26 Bytes

εS²Ä×J³Äи²0‹ií]³0‹iR}˜0ð:»

Nimmt die Eingabe als Liste von 8-Bit-Binärzeichenfolgen und gibt sie 1als Nicht-Leerzeichen aus.

-1 Byte dank @MagicOctopusUrn .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

ε         # Map the (implicit) input-list to:
 S        #  Convert the binary-String to a list of characters
  ²Ä      #  Take the absolute value of the second input
    ×     #  And repeat each character that many times
     J    #  And then join it back together to a single string again
 ³Ä       #  Take the absolute value of the third input
   и      #  Repeat that string as a list that many times
 ²0‹i     #  If the second input is negative:
     í    #   Reverse each string in the list
]         # Close both the if-statement and (outer) map
³0‹i }    # If the third input is negative:
    R     #  Reverse the list of lists
      ˜   # Flatten the list of lists to a list of strings
0ð:       # Replace all 0s with spaces " "
   »      # And join the strings by newlines (which is output implicitly)

MATL , 24 19 Bytes

B,!i|1&Y"2M0<?XP]Zc

Eingaben sind eine Reihe von Dezimalzahlen, horizontale Skala, vertikale Skala.

Probieren Sie es online!

Erläuterung

B        % Implicit input: array of numbers. Convert to binary. Gives a zero-one
         % matrix, each row containing the binary expansion of a number
,        % Do twice
  !      %   Transpose
  i      %   Input: number
  |      %   Absolute value
  1&Y"   %   Repeat each row that many times
  2M     %   Push the latest input again
  0<     %   Is it negative?
  ?      %   If so:
    XP   %     Flip vertically
  ]      %   End
  Zc     %   Convert each nonzero into '#'. Zeros are displayed as space
         % Implicit end. Implicit display

Dyalog APL, 46 42 33 Bytes

' #'[⍉⊃{⊖⍣(0>⍺)⍉⍵/⍨|⍺}/⎕,⊂⎕⊤⍨8/2]

Probieren Sie es online!

-9 danke an ngn!

Prolog (SWI) , 252 Bytes

N+E+R:-N<1,R=[];N-1+E+S,R=[E|S].
N*E*R:-R=E,E=[];N<0,reverse(E,F),-N*F*R;[H|T]=E,N+H+S,N*T*U,append(S,U,R).
N/E/R:-N<1,R=[];(E<N,D=E,F=32;D=E-N,F=35),N/2/D/C,R=[F|C].
[H|T]^X^Y^R:-128/H/A,X*A*B,Y*[[10|B]]*C,append(C,D),(T=[],R=D;T^X^Y^S,append(D,S,R)).

Probieren Sie es online!

Erläuterung

N+E+R:-N<1,R=[];N-1+E+S,R=[E|S].   Make `R` a list containing `E` repeated `N` times
       N<1,R=[]                    If `N<1`, let `R` be the empty list
       N-1+E+S                     Else recurse with `N-1`, `E` and `S`
           R=[E|S]                 Let `R` be a new list with `E` as head and `S` as tail
N*E*R:-R=E,E=[];N<0,reverse(E,F),-N*F*R;[H|T]=E,N+H+S,N*T*U,append(S,U,R).
                                   Let `R` be a list
                                   with each element in `E` repeated `N` times
                                   e.g. 2*[3, 6] -> [3, 3, 6, 6]
       R=E,E=[]                    Let `R` be `E` if `E` is the empty list
       N<0,reverse(E,F)            Else if `N<0`, let `F` be the reverse of `E`
           -N*F*R                  Recurse with `-N`, `F` and `R`
       [H|T]=E                     Else let `H` be the head and `T` be the tail of `E`
           N+H+S                   Let `S` be `N+H+S` (our function, not addition)
           N*T*U                   Recurse with `N`, `T` and `U`
           append(S,U,R)           let `R` be the concatenation of `S` and `U`
N/E/R:-N<1,R=[];(E<N,D=E,F=32;D=E-N,F=35),N/2/D/C,R=[F|C].
                                   Make `R` the binary representation of `E`
                                   with `N` as the value of the current bit
                                   where 0 and 1 are space and hash respectively
    N<1,R=[]                       If `N<1` let `R` be the empty list
    (
        E<N,D=E,F=32               If `E<N` the bit isn't set, so `D=E`, `F=space`
        D=E-N,F=35                 Else `D=E-N`, `F=hash`
    )
        N/2/D/C                    Recurse with `N/2`, `D` and `C`
        R=[F|C]                    Let `R` be a new list with `F` as head and `C` as tail
[H|T]^X^Y^R:-128/H/A,X*A*B,Y*[[10|B]]*C,append(C,D),(T=[],R=D;T^X^Y^S,append(D,S,R)).
                                   Make `R` the result,
                                   with inputs being the list `[H|T]`
                                   and the scales `X` and `Y`
   128/H/A                         Let `A` be the binary representation of `H` (8 bits)
   X*A*B                           Let `B` be `A` with each element repeated `X` times
   Y*[[10|B]]*C                    Let `C` be `B` with a newline prepended,
                                   repeated `Y` times
   append(C,D)                     Let `D` be `C` flattened by one level (joining lines)
   (
       T=[],R=D                    If `T` is empty, let `R` be `D` 
       T^X^Y^S                     Else recurse with `T`, `X`, `Y` and `S`
           append(D,S,R)           Let `R` be the concatenation of `D` and `S`
   )

Kohle , 28 Bytes

ＦθＥ↔ζ⭆⮌↨ι²×§ Xμ↔ηＦ›η⁰‖Ｆ‹ζ⁰‖↓

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

Ｆθ

Durchlaufen Sie die Liste der Bytes.

Ｅ↔ζ

Ordnen Sie den vertikalen Skalierungsfaktor zu und multiplizieren Sie so die Ausgabelinien.

⭆⮌↨ι²×§ Xμ↔η

Konvertieren Sie die Eingabe in Basis 2, kehren Sie sie um, ordnen Sie die Ziffern dem Leerzeichen zu und Xmultiplizieren Sie dann jedes Zeichen mit dem horizontalen Skalierungsfaktor.

Ｆ›η⁰‖

Wenn der horizontale Skalierungsfaktor positiv war, reflektieren Sie, um das Bild wieder in die richtige Richtung zu bringen.

Ｆ‹ζ⁰‖↓

Vertikal spiegeln, wenn der vertikale Skalierungsfaktor negativ war.

C (clang) , 120 Bytes

k,w,l,_;f(*o,z,x,y){for(w=z*y;w;)for(k=w>0?z*y-w--:++w,_=l=8*x;_;putchar(_?o[k/y]>>(l>0?--l/x:7-++l/x)&1?88:46:10))_=l;}

Probieren Sie es online!

Common Lisp , 157 Bytes

(lambda(l x y)(dolist(i(if(< y 0)(reverse l)l))(dotimes(j(abs y))(dotimes(n 8)(dotimes(k(abs x))(princ(if(logbitp(if(< x 0)n(- 7 n))i)"#"" "))))(princ"
"))))

Probieren Sie es online!

Erläuterung

(lambda(l x y)                           ; Lambda with parameters `l`, `x`, `y`
    (dolist
        (i                               ; For `i` in the list  
            (if(< y 0)(reverse l)l)      ; The reverse of `l` if `y<0` else `l`
        )
        (dotimes(j(abs y))(dotimes(n 8)(dotimes(k(abs x))
                                         ; Do `y` times, for `n` from 0 to 7, do `x` times
        (princ(if(logbitp(if(< x 0)n(- 7 n))i)"#"" "))))
                                         ; If `x<0` and the `n`th bit is 1
                                         ; or `x>0` and the `7-n`th bit is 1
                                         ; print "#", else print " "
        (princ"
")                                       ; After every `y` loop, print a newline
        )
    )
)

Tcl , 192 Bytes

proc f {l x y} {lmap i [if $y<0 {lreverse $l} {lindex $l}] {time {lmap n {0 1 2 3 4 5 6 7} {time {puts -nonewline [expr $i&1<<($x<0?$n:7-$n)?{#}:{ }]} [expr abs($x)]};puts {}} [expr abs($y)]}}

Probieren Sie es online!

proc f {l x y}                           Define a function `f` with arguments `l`, `x`, `y`
{lmap i                                  For each `i` in
    [if $y<0 {lreverse $l} {lindex $l}]  The reverse of `l` if `y<0` else `l`
    {
        time {                           Do `abs(y)` times
            lmap n {0 1 2 3 4 5 6 7} {   For `n` from 0 to 7
                time {                   Do `abs(x)` times
                    puts -nonewline      Print without newline
                         [expr $i&1<<($x<0?$n:7-$n)?{#}:{ }]
                                         If `x<0` and the `n`th bit is 1 or
                                         `x>0` and the `7-n`th bit is 1
                                         then return "#" else return " "
                } [expr abs($x)]
            };
            puts {}                      Print a newline
        } [expr abs($y)]
    }
}

8088 Maschinencode, IBM PC DOS, 77 71 Bytes

Gebaut:

B402 84FF 7906 FD03 F14E F6DF 518A CFAC 5051 B108 8AF3 84F6 7902 F6DE
518A CEB2 2384 DB79 04D0 C8EB 02D0 C072 02B2 2050 CD21 58E2 FA59 E2E4
B20D CD21 B20A CD21 5958 E2CC 59E2 C5

Auflistung:

    PR_BMP  MACRO BMP, SZBMP, ZX, ZY
            LOCAL LOOP_Y, LOOP_Y2, LOOP_X, LOOP_X2, X_POS, X_NEG
B4 02   MOV  AH, 2          ; DOS display char function 
84 FF   TEST ZY, ZY         ; is Y scale negative?
79 06   JNS  LOOP_Y         ; if positive, start Y LOOP
FD      STD                 ; direction flag start from end
03 F1   ADD  BMP, CX        ; advance input byte array to end
4E      DEC  BMP            ; zero adjust index
F6 DF   NEG  ZY             ; make counter positive
     LOOP_Y:    
51      PUSH CX             ; save outer byte loop counter
8A CF   MOV  CL, ZY         ; set up repeat counter (Y scale factor)
AC      LODSB               ; load byte into AL
     LOOP_Y2:
50      PUSH AX             ; save original AL
51      PUSH CX             ; save outer loop
B1 08   MOV  CL, 8          ; loop 8 bits
8A F3   MOV  DH, ZX         ; DH is positive X scale used as counter
84 F6   TEST ZX, ZX         ; is X scale negative?
79 02   JNS  LOOP_X         ; if so, make counter positive
F6 DE   NEG  DH             ; compliment X counter 
    LOOP_X:
51      PUSH CX             ; save bit counter
8A CE   MOV  CL, DH         ; set repeat counter (X scale factor)
B2 23   MOV  DL, '#'        ; by default, display a #
84 DB   TEST ZX, ZX         ; is X scale negative?
79 04   JNS  X_POS          ; if so, rotate left 1 bit
D0 C8   ROR  AL, 1          ; else rotate right LSB into CF
EB 02   JMP  X_NEG          ; jump to examine CF
    X_POS:
D0 C0   ROL  AL, 1          ; rotate left MSB into CF
    X_NEG:
72 02   JC   LOOP_X2        ; is a 1?   
B2 20   MOV  DL, ' '        ; if not, display a space
    LOOP_X2:    
50      PUSH AX             ; save AL (since silly DOS overwrites it)
CD 21   INT  21H            ; display char
58      POP  AX             ; restore AL
E2 FA   LOOP LOOP_X2        ; loop repeat counter
59      POP  CX             ; restore bit counter
E2 E4   LOOP LOOP_X         ; loop bit counter
B2 0D   MOV  DL, 0DH        ; display CRLF
CD 21   INT  21H
B2 0A   MOV  DL, 0AH
CD 21   INT  21H
59      POP  CX             ; restore outer loop
58      POP  AX             ; restore original AL
E2 CC   LOOP LOOP_Y2        ; loop row display
59      POP  CX             ; restore byte counter
E2 C5   LOOP LOOP_Y         ; loop byte counter
    ENDM

Es stellte sich heraus, dass dies in ASM eher ein Trottel war, als ich ursprünglich gedacht hatte. Mehrere gleichzeitige Schleifen und viele if / else-Verzweigungen können Ihnen sicherlich Kopfschmerzen bereiten.

Dies ist als MAKRO implementiert, da es die Übergabe funktionsähnlicher Parameter zum Testen ermöglicht.

Ausgabe

Hier ist ein Testprogramm für DOS, das zur Eingabe des X- und Y-Skalierungsfaktors auffordert und auf dem Bildschirm anzeigt. Wenn Sie den Drachen zu stark skalieren, wird ein Bildlauf nach oben ausgeführt, da das Standard-DOS-Fenster nur 24 Zeilen enthält.

Und hier ist unser kleiner Drache (Ente):

Probieren Sie es online!

Sie können in einer DOS-VM mit DOSBox oder VirtualConsoles.com mit den folgenden Schritten testen :

1. VCS.ZIP herunterladen (enthält alle vier ausführbaren Dateien)
2. Gehen Sie zu https://virtualconsoles.com/online-emulators/DOS/
3. Laden Sie die soeben heruntergeladene ZIP-Datei hoch und klicken Sie auf Start
4. Geben Sie PLANE, KEY, TANKoder DRAGON.

Perl 5, 105 Bytes

($_,$h,$v)=@F;say for map{$_=reverse if$h<0;y/0/ /;s/./$&x abs$h/eg;($_)x abs$v}$v<0?reverse/\d+/g:/\d+/g

TIO

Wenn die Eingabe hex sein muss

126 Bytes

Jelly , 21 Bytes

⁴²+BḊ€⁸m€Ṡ}¥xA}ZʋƒYo⁶

Probieren Sie es online!

Angenommen, es gibt höchstens ein Befehlszeilenargument.

APL (Dyalog Extended) , 23 Byte ^SBCS

Dzaima-Methode

$(v,h,B)$$v$$h$$B$⎕IO←0

' x'⊇⍨∘⊃{⊖⍣(>⍺)⍉⍵/⍨|⍺}/

Probieren Sie es online!

{… }/ Reduzieren Sie von rechts nach links mit dem folgenden anonymen Lambda:

 |⍺ die Größe des linken Arguments (der Skalierungsfaktor)

 ⍵/⍨ Verwenden Sie dies, um das richtige Argument horizontal zu replizieren

 ⍉ transponieren

 ⊖⍣(… ) Umdrehen, wenn:

  >⍺ Der Skalierungsfaktor ist kleiner als Null

⊃ offenbaren (da Reduktion beigefügt, um Tensorrang von 1 auf 0 zu reduzieren)

' x'⊇⍨ Wählen Sie mithilfe dieser Matrix Elemente aus der Zeichenfolge "x" aus

Ruby , 89 Bytes

->b,w,h{y=h>0?-1:0;(b*h.abs).map{y+=1;[*1+8*w..0,*0...8*w].map{|x|' X'[b[y/h][x/w]]}*''}}

Probieren Sie es online!

T-SQL, 216 Bytes

Drücken Sie vor dem Ausführen dieser MS-SQL Studio-Verwaltung die Tastenkombination STRG-T, um Daten als Text anzuzeigen. Die Höhe kann nicht angepasst werden, um die Anzahl der Elemente in der Eingabe zu überschreiten.

Aufgrund der schrecklichen Implementierung von STRING_AGG funktioniert die Höhenvariable nur in MSSM. MS sollte einen dritten optionalen Parameter angegeben haben, um die Reihenfolge der zu verkettenden Elemente einzuschließen.

Die Online-Version kann nur die Anpassung der Breite unterstützen. Die Höhe führt zu einem flippigen Ergebnis mit mehreren Stapelformen.

USE master
DECLARE @ table(v int,i int identity)
INSERT @ values
(0x06),(0x0F),(0xF3),(0xFE),(0x0E),(0x04),
(0x04),(0x1E),(0x3F),(0x7F),(0xE3),(0xC3),
(0xC3),(0xC7),(0xFF),(0x3C),(0x08),(0x8F),
(0xE1),(0x3F)
-- @  = width
-- @h = height
DECLARE @s INT=1,@h INT=1

SELECT iif(@s>0,reverse(x),x)FROM(SELECT
string_agg(replicate(iif(v&n=0,' ','X'),abs(@s)),'')x,i,j
FROM(values(1),(2),(4),(8),(16),(32),(64),(128))x(n)
,@,(SELECT top(abs(@h))i j FROM @)g GROUP BY i,j)f
ORDER BY i*@h

Dieses Skript zeigt in der Online-Version nicht die richtigen Formen an, daher habe ich einige geringfügige Anpassungen vorgenommen, um dies auszugleichen. Probieren Sie es online aus