En grandissant, mon premier système de jeu sur console était un Atari 2600 et j'aurai toujours un amour pour certains de ces jeux que j'aimais tant quand j'étais enfant. De nombreux graphiques sont toujours mémorables, peut-être même emblématiques.

Il s'avère que ces sprites sont des images bitmap très simplistes, de 8 pixels de large à hauteur variable où la représentation binaire est l'agencement des pixels.

Par exemple, les octets hexadécimaux 0x18, 0x24, 0x18 dessineraient un cercle brut comme ceci:

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

Comme 8 pixels de large créent des graphiques assez petits (même selon les normes Atari 2600), il était courant de doubler ou quadrupler la hauteur, la largeur ou les deux pour créer une version plus grande (bien que plus en blocs et déformée) de la même image. Ils seraient généralement également inversés verticalement ou horizontalement pour les sprites des joueurs et les terrains de jeu. Le jeu Combat en est un bon exemple.

Le défi consiste à écrire du code pour afficher ces images-objets sous forme de «graphiques» sous forme ASCII, y compris la possibilité de les étirer ou de les retourner verticalement, horizontalement ou les deux. Cela doit être sous la forme d'un programme complet ou d'une fonction appelable.

Contribution:

• Un tableau d'octets, chacun représentant les bits horizontaux pour cette ligne.
• Une valeur entière non nulle pour chaque direction, horizontale et verticale représentant le facteur d'échelle pour cette dimension.
• Une valeur négative indique que la dimension doit également être inversée le long de son axe.

Sortie:

• Représentation ASCII en STDOUT ou une chaîne séparée par des sauts de ligne, en utilisant un caractère espace pour les pixels noirs (0) et tout caractère imprimable non espace de votre choix pour les pixels blancs (1).

Données de test:

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]

Remarque: Les tableaux d'entrée d'octets ci-dessus sont fournis sous forme hexadécimale. Si votre plate-forme n'accepte pas les littéraux hexadécimaux pour la représentation des octets, vous pouvez les convertir en un littéral équivalent octet natif.

Exemple de sortie:

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

Remarque: les lignes horizontales au-dessus et en dessous doivent indiquer le début et la fin de la sortie. Ils ne sont pas requis dans la sortie, mais des lignes vides (représentées par tous les zéros / espaces) au début et / ou à la fin sont requises, comme indiqué.

Note 2: ces bitmaps de test ont été inspirés et recréés / codés sur la base de captures d'écran de jeu étiquetées comme "fair use" sur Wikipédia.

Critères gagnants

• Il s'agit de code-golf , donc le code le plus court en octets par langue gagne.
• Les failles standard sont interdites.

Python 2 , 117 octets

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

Essayez-le en ligne!

05AB1E , 27 26 octets

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

Prend l'entrée comme une liste de chaînes binaires de 8 bits et les sorties avec 1comme caractère non-espace.

-1 octet grâce à @MagicOctopusUrn .

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

ε         # 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 octets

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

Les entrées sont un tableau de nombres décimaux, échelle horizontale, échelle verticale.

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

-9 grâce à ngn!

Prolog (SWI) , 252 octets

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

Essayez-le en ligne!

Explication

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

Fusain , 28 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｆθ

Faites une boucle sur la liste des octets.

Ｅ↔ζ

Carte sur le facteur d'échelle vertical, multipliant ainsi les lignes de sortie.

⭆⮌↨ι²×§ Xμ↔η

Convertissez l'entrée en base 2, inversez-la, mappez les chiffres à l'espace X, puis multipliez chaque caractère par le facteur d'échelle horizontal.

Ｆ›η⁰‖

Si le facteur d'échelle horizontal était positif, réfléchissez pour obtenir à nouveau l'image dans le bon sens.

Ｆ‹ζ⁰‖↓

Refléter verticalement si le facteur d'échelle vertical était négatif.

C (clang) , 120 octets

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

Essayez-le en ligne!

Lisp commun , 157 octets

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

Essayez-le en ligne!

Explication

(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 octets

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

Essayez-le en ligne!

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

Code machine 8088, IBM PC DOS, 77 71 octets

Assemblé:

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

Référencement:

    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

Cela s'est avéré être plus compliqué dans l'ASM que je ne le pensais à l'origine. Plusieurs boucles simultanées et de nombreuses ramifications if / else peuvent certainement vous donner des maux de tête.

Ceci est implémenté en tant que MACRO car il permet le passage de paramètres de type fonction pour les tests.

Production

Voici un programme de test pour DOS qui demande le facteur d'échelle X et Y et qui s'affiche à l'écran. Notez que la mise à l'échelle trop importante du dragon défilera au-dessus du haut, car la fenêtre DOS par défaut ne comporte que 24 lignes.

Et voici notre petit dragon (canard):

Essayez-le en ligne!

Vous pouvez tester dans une machine virtuelle DOS en utilisant DOSBox ou VirtualConsoles.com avec les étapes suivantes:

1. Télécharger VCS.ZIP (contient les quatre exécutables)
2. Accédez à https://virtualconsoles.com/online-emulators/DOS/
3. Téléchargez le fichier ZIP que vous venez de télécharger, cliquez sur Démarrer
4. Tapez PLANE, KEY, TANKou DRAGON.

Perl 5, 105 octets

($_,$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

Si l'entrée doit être hexadécimale

126 octets

Gelée , 21 octets

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

Essayez-le en ligne!

Suppose qu'il existe au plus un argument de ligne de commande.

APL (Dyalog Extended) , 23 octets ^SBCS

méthode de dzaima

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

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

Essayez-le en ligne!

{… }/ Réduisez de droite à gauche en utilisant le lambda anonyme suivant:

 |⍺ la magnitude de l'argument de gauche (le facteur d'échelle)

 ⍵/⍨ l'utiliser pour répliquer le bon argument horizontalement

 ⍉ transposer

 ⊖⍣(… ) Retourner si:

  >⍺ le facteur d'échelle est inférieur à zéro

⊃ divulguer (depuis la réduction incluse pour réduire le rang du tenseur de 1 à 0)

' x'⊇⍨ sélectionner des éléments de la chaîne "x" en utilisant cette matrice

Rubis , 89 octets

->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]]}*''}}

Essayez-le en ligne!

T-SQL, 216 octets

Avant d'exécuter cette gestion MS-SQL Studio, appuyez sur CRTL-t pour afficher les données sous forme de texte. La hauteur ne peut pas être ajustée pour dépasser le nombre d'éléments dans l'entrée.

En raison de l'horrible implémentation de STRING_AGG , la variable de hauteur ne fonctionnera que dans MSSM. MS aurait dû créer un troisième paramètre facultatif pour inclure l'ordre des éléments à concaténer.

La version en ligne ne peut prendre en charge que le réglage de la largeur. La hauteur se traduira par un résultat funky avec plusieurs formes d'empilement.

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

Ce script n'affichera pas les formes correctes dans la version en ligne, j'ai donc fait quelques ajustements mineurs pour compenser. Essayez-le en ligne