자라면서, 나의 첫 콘솔 게임 시스템은 Atari 2600이었고, 나는 어렸을 때 좋아했던 게임들에 대해 항상 사랑할 것입니다. 많은 그래픽이 여전히 기억에 남으며 아마도 상징적입니다.

이 스프라이트는 이진 표현이 픽셀의 배열 인 가변 높이를 가진 8 픽셀 너비의 매우 단순한 비트 맵임을 알 수 있습니다.

예를 들어 16 진 바이트 0x18, 0x24, 0x18은 다음과 같이 원을 그립니다.

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

너비가 8 픽셀이면 상당히 작은 그래픽 (Atari 2600 표준으로도)이 만들어 지므로 높이, 너비 또는 둘 모두를 두 배 또는 네 배로 늘려서 동일한 이미지의 더 큰 (더 블록적이고 왜곡 된) 버전을 만드는 것이 일반적이었습니다. 또한 플레이어 스프라이트와 플레이 필드 모두에서 수직 또는 수평으로 뒤집어집니다. Combat 게임 이 좋은 예입니다.

문제는 이러한 스프라이트를 세로, 가로 또는 양쪽으로 늘리거나 뒤집는 기능을 포함하여 이러한 스프라이트를 ASCII 형식으로 "그래픽"으로 표시하는 코드를 작성하는 것입니다. 이것은 전체 프로그램 또는 호출 가능한 함수의 형태 여야합니다.

입력:

• 각 줄의 가로 비트를 나타내는 바이트 배열입니다.
• 각 방향에 대한 0이 아닌 정수 값, 가로 및 세로는 해당 차원의 배율을 나타냅니다.
• 음수 값은 치수를 축을 따라 뒤집어 야 함을 나타냅니다.

산출:

• 검은 색 (0) 픽셀에 공백 문자를 사용하고 흰색 (1) 픽셀에 대해 선택 가능한 인쇄 가능하고 공백이 아닌 문자를 사용하여 STDOUT 또는 줄 바꿈으로 구분 된 문자열로 ASCII 표현.

테스트 데이터 :

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]

참고 : 위의 예제 입력 배열은 16 진수로 제공됩니다. 플랫폼이 바이트 표현을 위해 16 진 리터럴을 허용하지 않는 경우이를 바이트 단위의 고유 리터럴로 변환 할 수 있습니다.

출력 예 :

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

참고 : 위와 아래의 수평선은 출력의 시작과 끝을 나타냅니다. 출력에는 필요하지 않지만 표시된대로 시작 및 / 또는 끝에 빈 줄 (모든 0 / 공백으로 표시)이 필요합니다.

참고 2 :이 테스트 비트 맵은 Wikipedia에서 "공정 사용"으로 표시된 게임 스크린 샷을 기반으로 영감을 얻은 후 다시 그려 지거나 코딩되었습니다.

승리 기준

• 이것은 code-golf 이므로 언어 ​​당 가장 짧은 코드 (바이트)가 이깁니다.
• 표준 허점 은 금지되어 있습니다.

파이썬 2 , 117 바이트

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

온라인으로 사용해보십시오!

05AB1E , 27 26 바이트

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

입력을 8 비트 이진 문자열 목록으로 가져 와서 1공백이 아닌 문자로 출력 합니다.

@MagicOctopusUrn 덕분에 -1 바이트 .

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

ε         # 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 바이트

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

입력은 십진수, 수평 스케일, 수직 스케일의 배열입니다.

온라인으로 사용해보십시오!

설명

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 바이트

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

온라인으로 사용해보십시오!

ngn 덕분에 -9!

프롤로그 (SWI) , 252 바이트

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

온라인으로 사용해보십시오!

설명

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

숯 , 28 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

Ｆθ

바이트 목록을 반복합니다.

Ｅ↔ζ

수직 스케일링 계수를 매핑하여 출력 라인을 곱하십시오.

⭆⮌↨ι²×§ Xμ↔η

입력을 밑이 2로 변환하고, 뒤집고, 숫자를 공백에 매핑 X한 다음 각 문자에 가로 배율을 곱하십시오.

Ｆ›η⁰‖

수평 스케일링 계수가 양수이면 이미지를 다시 올바른 방향으로 가져옵니다.

Ｆ‹ζ⁰‖↓

수직 스케일링 계수가 음수이면 수직으로 반사하십시오.

C (클랑) , 120 바이트

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

온라인으로 사용해보십시오!

공통 리스프 , 157 바이트

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

온라인으로 사용해보십시오!

설명

(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 바이트

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

온라인으로 사용해보십시오!

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 머신 코드, IBM PC DOS, 77 71 바이트

조립 :

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

리스팅 :

    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

이것은 내가 원래 생각했던 것보다 ASM에서 더 두터운 것으로 판명되었습니다. 여러 개의 동시 루프와 많은 if / else 분기는 확실히 두통을 줄 수 있습니다.

이것은 테스트를 위해 함수와 같은 매개 변수 전달을 허용하기 때문에 MACRO로 구현됩니다.

산출

다음은 X 및 Y 스케일링 계수를 프롬프트하고 화면을 그리는 DOS 용 테스트 프로그램입니다. 기본 DOS 창이 24 행이므로 드래곤을 너무 많이 스케일하면 맨 위로 스크롤됩니다.

그리고 여기 우리의 작은 용 (오리)이 있습니다 :

온라인으로 사용해보십시오!

다음 단계에 따라 DOSBox 또는 VirtualConsoles.com 을 사용하여 DOS VM에서 테스트 할 수 있습니다 .

1. VCS.ZIP 다운로드 (4 개의 실행 파일 모두 포함)
2. https://virtualconsoles.com/online-emulators/DOS/로 이동 하십시오
3. 다운로드 한 ZIP 파일을 업로드하고 시작을 클릭하십시오.
4. 입력 PLANE, KEY, TANK또는 DRAGON.

펄 5, 105 바이트

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

입력이 16 진수 여야하는 경우

126 바이트

젤리 , 21 바이트

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

온라인으로 사용해보십시오!

최대 하나의 명령 줄 인수가 있다고 가정합니다.

APL (Dyalog Extended) , 23 바이트 ^SBCS

dzaima의 방법

익명의 암묵적 접두사 기능. 소요$(v,h,B)$ 인수로 $v$ 수직 스케일링 계수입니다. $h$ 수평 스케일링 계수이며 $B$바이트 배열은 8 열 묶음 비트 부울 행렬입니다 (이것은 APL에서 원시 바이트를 나타내는 일반적이고 가장 간단한 방법입니다). 필요합니다 ⎕IO←0(0부터 시작).

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

온라인으로 사용해보십시오!

{… }/ 다음 익명 람다를 사용하여 오른쪽에서 왼쪽으로 줄입니다.

 |⍺ 왼쪽 인수의 크기 (확대 인자)

 ⍵/⍨ 그것을 사용하여 올바른 인수를 수평으로 복제하십시오

 ⍉ 바꾸어 놓다

 ⊖⍣(… 다음과 같은 ) 경우 뒤집습니다.

  >⍺ 스케일링 계수가 0보다 작은 경우

⊃ 공개 (텐서 순위를 1에서 0으로 줄이기 위해 포함 된 축소 이후)

' x'⊇⍨ 해당 행렬을 사용하여 문자열 "x"에서 요소를 선택하십시오.

루비 , 89 바이트

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

온라인으로 사용해보십시오!

T-SQL, 216 바이트

이 MS-SQL Studio Management를 실행하기 전에 CRTL-t를 눌러 데이터를 텍스트로 표시하십시오. 입력의 요소 수를 초과하도록 높이를 조정할 수 없습니다.

STRING_AGG 의 끔찍한 구현으로 인해 height 변수는 MSSM에서만 작동합니다. MS는 연결되는 요소의 순서를 포함하기 위해 세 번째 선택적 매개 변수를 작성해야합니다.

온라인 버전은 너비 조정 만 지원할 수 있습니다. 높이는 여러 스태킹 모양으로 펑키 한 결과를 낳습니다.

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

이 스크립트는 온라인 버전에서 올바른 모양을 보여주지 않기 때문에 약간의 보정이 이루어졌습니다. 온라인으로 사용해보십시오