Lớn lên, hệ thống trò chơi console đầu tiên của tôi là Atari 2600 và tôi sẽ luôn yêu thích một số trò chơi mà tôi rất thích khi còn nhỏ. Nhiều đồ họa vẫn còn đáng nhớ, thậm chí có thể mang tính biểu tượng.

Nó chỉ ra rằng các sprite này là bitmap rất đơn giản, rộng 8 pixel với chiều cao thay đổi trong đó biểu diễn nhị phân là sự sắp xếp của các pixel.

Ví dụ: các byte hex 0x18, 0x24, 0x18 sẽ vẽ một vòng tròn thô như vậy:

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

Vì chiều rộng 8 pixel tạo ra đồ họa khá nhỏ (thậm chí theo tiêu chuẩn Atari 2600), thông thường sẽ tăng gấp đôi hoặc gấp bốn lần chiều cao, chiều rộng hoặc cả hai để tạo ra một phiên bản lớn hơn (mặc dù nhiều khối và méo hơn) của cùng một hình ảnh. Chúng thường cũng được lật theo chiều dọc hoặc ngang cho cả họa tiết người chơi và sân chơi. Trò chơi Combat là một ví dụ tốt về điều này.

Thách thức là, viết mã để hiển thị các họa tiết này dưới dạng "đồ họa" ở dạng ASCII bao gồm khả năng kéo dài hoặc lật chúng theo chiều dọc, chiều ngang hoặc cả hai. Điều này phải ở dạng một chương trình đầy đủ hoặc chức năng có thể gọi được.

Đầu vào:

• Một mảng byte, mỗi byte đại diện cho các bit ngang cho dòng đó.
• Giá trị nguyên khác không cho mỗi hướng, ngang và dọc biểu thị hệ số tỷ lệ cho kích thước đó.
• Giá trị âm biểu thị rằng kích thước cũng nên được lật dọc theo trục của nó.

Đầu ra:

• Biểu diễn ASCII thành STDOUT hoặc chuỗi phân tách dòng mới, sử dụng ký tự khoảng trắng cho pixel (0) màu đen và bất kỳ ký tự không phải không gian có thể in nào bạn chọn cho pixel (1) màu trắng.

Dữ liệu kiểm tra:

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]

Lưu ý: Ví dụ về mảng đầu vào của byte được cung cấp dưới dạng hex. Nếu nền tảng của bạn không chấp nhận các ký tự hex để biểu diễn byte, bạn có thể chuyển đổi chúng thành một ký tự tương đương byte gốc.

Kết quả ví dụ:

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

Lưu ý: các đường ngang bên trên và bên dưới là để hiển thị đầu và cuối của đầu ra. Chúng không được yêu cầu trong đầu ra, tuy nhiên các dòng trống (được biểu thị bằng tất cả các số 0 / khoảng trắng) ở đầu và / hoặc cuối là bắt buộc, như được hiển thị.

Lưu ý 2: các bitmap thử nghiệm này được lấy cảm hứng và được vẽ lại / mã hóa dựa trên ảnh chụp màn hình trò chơi được gắn thẻ là "sử dụng hợp lý" trên Wikipedia.

Tiêu chí chiến thắng

• Đây là mã golf , vì vậy mã ngắn nhất tính theo byte cho mỗi ngôn ngữ sẽ thắng.
• Sơ hở tiêu chuẩn bị cấm.

Python 2 , 117 byte

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

Hãy thử trực tuyến!

05AB1E , 27 26 byte

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

Lấy đầu vào dưới dạng danh sách các chuỗi nhị phân 8 bit và đầu ra với 1ký tự không phải là khoảng trắng.

-1 byte nhờ @MagicOctopusUrn .

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

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

Đầu vào là một dãy các số thập phân, tỷ lệ ngang, tỷ lệ dọc.

Hãy thử trực tuyến!

Giải trình

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

APL Dyalog, 46 42 33 byte

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

Hãy thử trực tuyến!

-9 cảm ơn ngn!

Prolog (SWI) , 252 byte

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

Hãy thử trực tuyến!

Giải trình

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

Than , 28 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｆθ

Lặp lại danh sách các byte.

Ｅ↔ζ

Ánh xạ qua hệ số tỷ lệ dọc, do đó nhân các dòng đầu ra.

⭆⮌↨ι²×§ Xμ↔η

Chuyển đổi đầu vào thành cơ sở 2, đảo ngược nó, ánh xạ các chữ số thành không gian và Xsau đó nhân mỗi ký tự theo hệ số tỷ lệ ngang.

Ｆ›η⁰‖

Nếu hệ số tỷ lệ ngang là dương, hãy phản xạ để có được hình ảnh chính xác một lần nữa.

Ｆ‹ζ⁰‖↓

Phản xạ theo chiều dọc nếu hệ số tỷ lệ dọc là âm.

C (tiếng kêu) , 120 byte

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

Hãy thử trực tuyến!

Lisp thông thường , 157 byte

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

Hãy thử trực tuyến!

Giải trình

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

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

Hãy thử trực tuyến!

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

Mã máy 8088, IBM PC DOS, 77 71 byte

Lắp ráp:

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

Liệt kê:

    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

Điều này hóa ra là nhiều hơn một chút về ASM so với tôi nghĩ ban đầu. Nhiều vòng lặp đồng thời và rất nhiều nhánh if / khác chắc chắn có thể khiến bạn đau đầu.

Điều này được triển khai dưới dạng MACRO vì nó cho phép truyền tham số giống như chức năng để kiểm tra.

Đầu ra

Dưới đây là một chương trình thử nghiệm cho DOS nhắc nhở hệ số tỷ lệ X và Y và vẽ lên màn hình. Lưu ý, nhân rộng con rồng quá nhiều sẽ cuộn qua đầu vì cửa sổ DOS mặc định chỉ có 24 hàng.

Và đây là con rồng nhỏ của chúng tôi (vịt):

Hãy thử trực tuyến!

Bạn có thể kiểm tra trong VM VM bằng DOSBox hoặc VirtualConsoles.com với các bước sau:

1. Tải xuống VCS.ZIP (chứa tất cả bốn tệp thực thi)
2. Tới https://virtualconsoles.com/online-emulators/DOS/
3. Tải lên tệp ZIP bạn vừa tải xuống, nhấp Bắt đầu
4. Gõ PLANE, KEY, TANKhoặc DRAGON.

Perl 5, 105 byte

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

Nếu đầu vào phải là hex

126 byte

Thạch , 21 byte

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

Hãy thử trực tuyến!

Giả sử có nhiều nhất một đối số dòng lệnh.

APL (Dyalog mở rộng) , 23 byte ^SBCS

phương pháp của dzaima

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

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

Hãy thử trực tuyến!

{... }/ làm giảm từ phải sang trái bằng cách sử dụng lambda ẩn danh sau đây:

 |⍺ độ lớn của đối số bên trái (hệ số tỷ lệ)

 ⍵/⍨ sử dụng điều đó để tái tạo đối số đúng theo chiều ngang

 ⍉ hoán vị

 ⊖⍣(... ) lật nếu:

  >⍺ hệ số tỷ lệ nhỏ hơn 0

⊃ tiết lộ (kể từ khi giảm kèm theo để giảm thứ hạng tenor từ 1 xuống 0)

' x'⊇⍨ chọn các phần tử từ chuỗi "x" bằng ma trận đó

Ruby , 89 byte

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

Hãy thử trực tuyến!

T-SQL, 216 byte

Trước khi thực hiện Quản lý Studio MS-SQL này, nhấn CRTL-t để hiển thị dữ liệu dưới dạng văn bản. Không thể điều chỉnh chiều cao để vượt quá số lượng phần tử trong đầu vào.

Do việc triển khai STRING_AGG khủng khiếp , biến chiều cao sẽ chỉ hoạt động trong MSSM. MS nên tạo một tham số tùy chọn thứ ba để bao gồm thứ tự của các phần tử được nối.

Phiên bản trực tuyến chỉ có thể hỗ trợ điều chỉnh độ rộng. Chiều cao sẽ dẫn đến một kết quả thú vị với nhiều hình dạng xếp chồng.

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

Kịch bản này sẽ không hiển thị các hình dạng chính xác trong phiên bản trực tuyến, vì vậy tôi đã thực hiện một số điều chỉnh nhỏ để bù lại. Dùng thử trực tuyến