배경

할로윈 관련 도전이 있습니다.

마지막 도전 에서 보았 듯이 아스키 아트 애니메이션이라고하는 것을 아주 좋아합니다. 패턴을 그리는 것이 아니라 진행되는 패턴을 그리는 것입니다. 이 아이디어는 몇 년 전에 무작위 아스키 박쥐가 할로윈 화면을 가로 질러 날아가도록 프레젠테이션을 활기차게 요청한 후에 나에게 왔습니다. 말할 필요도없이 나는 (나는 돈을 받고 있었다) 무작위 박쥐보다 생명이 더 많다고 생각하게했다. 이것으로부터 영감을 얻어이 도전을 제안하고 싶습니다.

도전

박쥐가 달 주위를 날아 다니게합니다.

박쥐는 다음과 같습니다.

^o^

여기 달이 있습니다 :

     mmm         
   mmmmmmm       
  mmmmmmmmm      
   mmmmmmm       
     mmm     

박쥐 비행의 모든 ​​단계를 보여 주어야합니다 (출력 참조).

입력

없음

산출

      ^o^         
      mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm         


      mmm^o^      
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm         


      mmm         
    mmmmmmm^o^    
   mmmmmmmmm      
    mmmmmmm       
      mmm         


      mmm         
    mmmmmmm       
   mmmmmmmmm^o^   
    mmmmmmm       
      mmm         


      mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm^o^    
      mmm         


      mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm^o^      


      mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm         
      ^o^         


      mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
   ^o^mmm         


      mmm         
    mmmmmmm       
   mmmmmmmmm      
 ^o^mmmmmmm       
      mmm         


      mmm         
    mmmmmmm       
^o^mmmmmmmmm      
    mmmmmmm       
      mmm         


      mmm         
 ^o^mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm         


   ^o^mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm         


      ^o^         
      mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm   

규칙

• 외부 파일 또는 웹 사이트에서 읽지 않음
• 전체 프로그램 또는 기능을 제출할 수 있습니다
• 여분의 공백 및 / 또는 줄 바꿈은 괜찮습니다.
• 평소처럼 금지 된 표준 허점
• 박쥐는 달의 꼭대기에서 다시 마무리해야합니다
• 원하는 경우 프레임간에 화면을 지우십시오. 그러나 이것이 필수 사항은 아닙니다. 위의 출력은 괜찮습니다
• 이것이 코드 골프이기 때문에 어떤 대답이라도 환영받을지라도 우승자는 가장 낮은 바이트 수의 답이 될 것입니다

견본

완전히 ungolfed Python 2에서 참조 구현 (620 바이트이지만 수행 할 수 있음을 증명하기 위해 나중에 골프를 칠 수 있음).

b='^o^'
m=['                     ',
'         mmm         ',
'       mmmmmmm       ',
'      mmmmmmmmm      ',
'       mmmmmmm       ',
'         mmm         ',
'                     ']
p=[(9,12),(12,15),(14,17),(15,18),(14,17),(12,15),(9,12),(6,9),(4,7),(3,6),(4,7),(6,9),(9,12)]
d=0
for z in range(7):
    x=map(str,m[z])
    c="".join(x[:p[z][0]]) + b + "".join(x[p[z][1]:])+"\n"
    print "\n".join(m[:z]) + "\n" + c+"\n".join(m[z+1:])
for z in range(6)[::-1]:
    x=map(str,m[z])
    c="".join(x[:p[z+6][0]]) + b + "".join(x[p[z+6][1]:])+"\n"
    print "\n".join(m[:z]) + "\n" + c+"\n".join(m[z+1:])

결과

@Jonathan은 분명히 Jelly로 바이트 수를 얻었지만 @Oyarsa의 Brainfuck 답변을 순수하게 허용되는 답변으로 표시 할 것입니다. 왜냐하면 미친 언어로 실제로 이런 일을 할 수있는 사람은 +15의 대답이 필요하다고 생각하기 때문입니다. 필요한 바이트 수 골프 언어에 문제가 있기 때문이 아닙니다. 의심 스러우면 메타 에 관한 질문에 대한 내 대답을 참조하십시오 . 어떤 언어로든 기여한 모든 사람에게 많은 감사와 존경을 전합니다.

Brainfuck, 690 바이트

이번이 처음 골프입니다. 그래도 여전히 개선의 여지가 충분하다고 확신합니다

-[-[-<]>>+<]>-<<+++[>+++++++<-]>>>+>>-[<-->-------]<->++++++++>+>+++++>+>+++++>+>+++++++>+>+++++>+>+++++>+>++++++++>+>+>+>>+++[<++++++>-]<+>+>-->+>+>+[<]>[[<+>>-[>]+[[<]>+[>]<+[<]>>>-]<<[->>+<<]>-]>-[->>>>+<<<<]>++]>>>[[-]<]>>>>[>]>>+>+++++++<<<<[<]+<+<<+[[<]++++[>++++<-]>[<+[>]>[-<+>]<[<]>>-]>[>]++++++++++[>]>>>-[<]<<[<]<]<[<]>->-<<<[-]++++++<+<+++[>++++++<-]+<++++[>++++++++<-]---<-[>+<-----]++<----[>+<----]--<-[>+<---]<-[>++<-----]++++<-[>+<---]++<-[>+<-------]---<----[>+<----]<--[>+<++++++]<+++++[>+++++<-]++++++>[[[>]>[>]>>[-<<+>>]<<[<]<[<]>-]>[>]>[>]+++++++[>+++++++++<-]>-[->+>+>+<<<]++++[>>++++<<-]>>+<<<<[<]>[.>]>>[.>]<[<]>[-]>[-]>[-]<+[--<---[->]<]<[->+>+>+<<<]<<[[->>+<<]<]<]

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

가독성을 높이기 위해

-[-[-<]>>+<]>-<<+++[>+++++++<-]>>>+>>-[<-->-------]<->++++++++>+>+++++>+>+++++>+>+++++++>+>+++++>+>+++++>+>++++++++>+>+>+>>+++[<++++++>-]<+>+>-->+>+>+
Sets counters for creation of the m's and spaces
[<]>[[<+>>-[>]+[[<]>+[>]<+[<]>>>-]<<[->>+<<]>-]>-[->>>>+<<<<]>++]
Adds the first counter plus two of the character at the second counter to the end of the
current set of cells removes the first two counters on the list then repeats until
it encounters a 254
>>>[[-]<]>>>>[>]>>+>+++++++<<<<[<]
Removes some excess cells then adds a 7 after the end of the set of cells
+<+<<+[[<]++++[>++++<-]>[<+[>]>[-<+>]<[<]>>-]>[>]++++++++++[>]>>>-[<]<<[<]<]
Adds a newline every 16 characters until 7 newlines are added
<[<]>->-<<<[-]++++++<+<+++[>++++++<-]+<++++[>++++++++<-]---<-[>+<-----]++<----[>+<----]--<-[>+<---]<-[>++<-----]++++<-[>+<---]++<-[>+<-------]---<----[>+<----]<--[>+<++++++]<+++++[>+++++<-]++++++
Removes some excess cells then sets indices for the locations of bats
>[[[>]>[>]>>[-<<+>>]<<[<]<[<]>-]>[>]>[>]+++++++[>+++++++++<-]>-[->+>+>+<<<]++++[>>++++<<-]>>+<<<<[<]>[.>]>>[.>]<[<]>[-]>[-]>[-]<+[--<---[->]<]<[->+>+>+<<<]<<[[->>+<<]<]<]
Loops through the indices replacing the spaces at each index with a bat then printing 
the set of cells then changing the bat back to spaces

처음에 줄 바꿈을 추가하여 각 단계를 양방향으로 읽어 두 개의 다른 단계를 얻을 수 있다는 사실을 사용하고 싶었지만 전체 6 반 단계를 생성하지 않으면 좋은 방법을 찾을 수 없었습니다. 한 번에.

05AB1E , 69 62 60 바이트

Adnan 덕분에 2 바이트를 절약했습니다 .

3ð×…^o^)U13FNV0379730vð5y>;ï-y_+×N(Y-12%_Xè'my×NY-12%_y&XèJ,

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

설명

3ð×…^o^)U나중에 사용하기 위해 X 에 목록 [" ","^o^"]을 저장합니다 .

13FNV13 단계를 반복하고 [0 .. 12] 현재 반복 인덱스를 Y에 저장합니다 .

0379730v각 단계의 행을 반복합니다.
여기서 N 은 행 인덱스이고 y 는 현재 m 수입니다 .

floor(5/(y+1))-(y==0)로 각 행에 공백을 추가하여 시작합니다 ð5y>;ï-y_+×.

그런 다음 m 앞에 박쥐 또는 3 칸이 있어야하는지 결정합니다 .
경우 (-N-Y)%12 == 0사실 우리는 박쥐, 다른 3 개 공간을 추가 할 수 있습니다.
이 표현 N(Y-12%_Xè은 박쥐를 단계별로 배치 0,6-12합니다.

그런 다음 우리는 배치 Y m의 과를 'my×.

이제 m 다음에 박쥐 나 3 칸이 있어야하는지 결정합니다 .
코드 는 참이면 NY-12%_y&Xè박쥐를 배치하고 ((N-Y)%12 == 0) and y!=0그렇지 않으면 3 칸을 배치합니다.
이것은 박쥐를 무대에 놓을 것이다 1-5.

마지막으로 전체 행을 문자열로 결합하고 줄 바꿈으로 인쇄 J,합니다.

자바 스크립트 (ES6) 109 144 140 138 바이트

f=(k=13,b=y=>(y-k)%12?'   ':'^o^')=>k--?[0,3,7,9,7,3,0].map((n,y)=>' '.repeat(5-n/2+!n)+b(y)+'m'.repeat(n)+b(n?-y:.1)).join`
`+`
`+f(k):''

console.log(f());

애니메이션 버전

f=(k,b=y=>(y-k)%12?'   ':'^o^')=>[0,3,7,9,7,3,0].map((n,y)=>' '.repeat(5-n/2+!n)+b(-y)+'m'.repeat(n)+b(n?y:.1)).join`
`

var k =0;
setInterval(function() { o.innerHTML = f(k++) }, 150);

<pre id=o></pre>

HTML + JS, 153 149 바이트

n=setInterval(_=>o.innerText=`zzd
zc3e
 b7f
a9g
 l7h
zk3i
zzj`.replace(/\S/g,c=>parseInt(c,36)-n%12-10?`m`.repeat(c)||`   `:`^o^`,n++),1e3)

<pre id=o>

편집 : @RickHitchcock 덕분에 많은 바이트를 절약했습니다. 단지 배열의 여러 스트링 (13)을 반환 보링 버전은 132 131 바이트 :

_=>[...Array(13)].map((_,n)=>`zza
zl3b
 k7c
j9d
 i7e
zh3f
zzg`.replace(/\S/g,c=>parseInt(c,36)-n%12-10?`m`.repeat(c)||`   `:`^o^`))

젤리 , 76 69 58 바이트

⁾ mṁ11ż“椿¬®µ‘ŒḄ¤Œṙs⁴Y
_4¢ḣ;“^o^”;¢ṫ⁸¤
“½œ0CSbp\I7'ð½‘Ç€Y

TryItOnline

어떻게?

⁾ mṁ11ż“椿¬®µ‘ŒḄ¤Œṙs⁴Y - Link 1, make a moon (niladic)
⁾ m                     - literal " m"
   ṁ                    - reshape like
    11                  - 11 (interpreted as range(11)) -> " m m m m m "
                 ¤      - nilad followed by links as a nilad
       “椿¬®µ‘         - code page indexes [22,3,11,7,8,9]
               ŒḄ       - bounce -> [22,3,11,7,8,9,8,7,11,3,22]
      ż                 - zip -> [[22,' '],[3,'m'],[11,' '],...]
                  Œṙ    - run length decode -> "                      mmm           mmmmmmm        mmmmmmmmm        mmmmmmm           mmm                      "
                    s   - split into chunks of length
                     ⁴  - l6
                      Y - join with line feeds

_4¢ḣ;“^o^”;¢ṫ⁸¤ - Link 2, a moon with a bat placed: endIndex
_4              - subtract 4 (startIndex)
  ¢              - call last link (1) as a nilad
   ḣ            - ḣead to startIndex
    ;           - concatenate
     “^o^”      - literal "^o^"
          ;     - concatenate
              ¤ - nilad followed by links as a nilad
           ¢    - call last link (1) as a nilad
            ṫ⁸  - tail from endIndex

“½œ0CSbp\I7'ð½‘Ç€Y - Main link (niladic)
“½œ0CSbp\I7'𽑠   - code page indexes [10,30,48,67,83,98,112,92,73,55,39,24,10]
                   -    indices to the right of each bat in a constructed moon
               ǀ  - call last link (2) as a monad for each
                 Y - join on line feeds

파이썬 2 146 144 138 바이트

@Willem 덕분에 -2 바이트 ( ca를 반복하는 대신 변수 사용 map)

m='\n'.join(int(a)*' '+int(b)*'m'+3*' 'for a,b in zip('6643466','0379730'))
for b in" -;L[hrbQ@2' ":c=ord(b)-23;print(m[:c-3]+'^o^'+m[c:])

반복

'6643466' 달 앞의 공백 수입니다 (박쥐가 거기에 갈 것이기 때문에 비어있는 첫 번째와 마지막 줄에 6 개가 있습니다).

'0379730''m'각 줄의 달에있는 s 의 수입니다 .

는 zip에 이러한 문자를 압축을 풉니 a및 b과, 하늘의 달을 만들어 m각 라인에 3 후행 공백.

마지막 줄은 달 내 박쥐의 위치를 ​​가로 지르며 효과적으로 다음과 같습니다.

for c in(9,22,36,53,68,81,91,75,58,41,27,16,9):print(m[:c-3]+'^o^'+m[c:])

그러나 위치의 튜플은 23을 추가하여 인쇄 가능한 문자의 서수로 인코딩됩니다 (9는 인쇄 할 수 없으므로). 이 같은 나오고 " -;L[hrbQ@2' "및 c=ord(b)-23값을 추출하는 데 사용됩니다.

Autovim , 85 81 바이트

애니메이션은없고 아마도 골프를 타기도합니다 ... 아직도, 블록에있는 새로운 아이에게는 나쁘지 않습니다! (오토바이)

ñ9am␛ÿP2xÿP4xyjGpđp2o
%ce 15
®q=8j$p
®z=6␍"_d3hP
ñğyG12PğÿPC^o^␛v^y6@q==o␛6@z==O

그것을 실행하려면 :

autovim run ascii-bat.autovim -ni

설명

요컨대, 달을 그리고 복사하여 12 번 붙여 넣은 다음 두 개의 매크로를 사용합니다. 하나는 처음 7 개의 달에 박쥐를 추가하고 다른 하나는 마지막 6 개의 달을 추가합니다.

" Draw the moon
ñ                                 " Normal mode
 9am␛                            " Write 9 `m`
      ÿP                          " Duplicate the line
        2x                        " Delete two characters
          ÿP                      " Duplicate the line
            4x                    " Delete 4 characters
              yj                  " Yank two lines
                Gp                " Paste at the end of the file
                  đp              " inverts the current line with the previous
                    2o            " Add two line breaks

%ce 15                            " Center our moon

" Macros
®q=8j$p                           " Macro `q` jumps 8 lines, and pastes
                                  "   at the end
®z=6␍"_d3hP                      " Macro `z` jumps 6 lines and replaces
                                  "   the previous 3 characters by the default

" Draw all 12 moons and add the bats
                                  "   register's content
ñ                                 " Run in normal mode
 ğyG                              " Copy the moon we just drew
    12P                           " Duplicate the moon 12 times
       ğÿP                        " Duplicate the top line (gets 3 centered `m`)
          C^o^␛                  " Change the mmm by a bat
                v^y               " Copy the bat we just drew
                   6@q            " Add the first 6 bats
                      ==          " Center the bat
                        o␛       " Add a line under the bat
                           6@z    " Add the 6 last bats
                              ==  " Align the last bat in the center
                                O " Add a line over the last moon

PHP, 167 바이트

PHP로 작은 프로그램을 만들었습니다.

<?php foreach([0,3,7,9,7,3,0]as$l)$b.=str_pad(str_repeat('=',$l),15," ",2)."\n";foreach([6,25,43,60,75,89,102,83,65,48,33,19,6]as$x)echo substr_replace($b,'^o^',$x,3);

보다 자세한 버전은 다음과 같습니다.

// width of the moon
$moonsizes = [0,3,7,9,7,3,0];
// position where to place the bat
$positions = [6,25,43,60,75,89,102,83,65,48,33,19,6];
// prepare base moon painting
foreach($moonsizes as $size){
    $basepainting .= str_pad(str_repeat('=',$size),15," ",STR_PAD_BOTH)."\n";
}
// loop frames and place bat
foreach($positions as $position) {
    echo substr_replace($basepainting,'^o^',$position,3);
}

이 제안이 있으면 내 첫 번째 골프 골입니다. :)

파이썬 2, 112 바이트

b=['   ','^o^']
for k in range(91):r=k%7;print(b[k/7+r==12]*(r%6>0)+(r*(6-r)*8/5-5)*'m'+b[k/7%12==r]).center(15)

사진을 인쇄하십시오. 각 라인에는 세 부분이 있습니다

• 왼쪽의 잠재적 인 박쥐
• m달의 몇 가지
• 오른쪽의 잠재적 인 박쥐

이 부품들은 간격을 위해 크기가 15 인 상자에 연결되고 중앙에 있습니다. 박쥐가 중앙으로 이동하는 것을 피하기 위해 누락 된 박쥐는 길이가 같은 3 칸입니다. 달 위나 아래에있는 박쥐의 경우 왼쪽 막대 슬롯이 생략되고 오른쪽 슬롯이 사용됩니다.

91 개의 라인이 있습니다 : 13 개의 사진 각각에 대한 7 라인 사진. 이들은 divmod를 통해 카운트 업됩니다으로 k의 카운트 0에 91, (k/7, k%7)간다

(0, 0)
(0, 1)
(0, 2)
(0, 3)
(0, 4)
(0, 5)
(0, 6)
(1, 0)
(1, 1)
 ....
(12, 5)
(12, 6)

첫 번째 값 k/7을 그림으로, 두 번째 값 r=k%7을 그림 내에서 행 번호로 사용하면 먼저 그림별로 카운트 한 다음 각 그림 내에서 행 번호별로 0- 인덱싱됩니다.

m달의 의 수는 행 번호가 r=k%7로 변경 됩니다 [0,3,7,9,7,3,0]. 이것을 색인화하는 대신 공식이 더 짧았습니다. 편리한 자유도는에 0곱하면 빈 문자열이 제공되므로의 음수가 될 수 있다는 것 m입니다. 포물선과 바닥 나누기를 통해 수식을 얻었습니다 r*(6-r)*8/5-5.

이제 양쪽에 방망이를 그릴 지 빈 공간을 그릴 지 선택합니다. 배열 b=[' ','^o^']에는 옵션이 포함되어 있습니다.

그림 0의 맨 위 0 행 (위), 그림 1의 맨 1 행 (오른쪽), 그림 6의 6 행 (위). 따라서 행과 그림 번호가 같은지 여부를 쉽게 확인할 수 k/7==r있습니다. 그러나 그림 0처럼 보이려면 그림 12도 필요합니다. 따라서 그림 번호 modulo 12를 먼저 가져옵니다.

왼쪽에는 비슷합니다. 박쥐 r=5,4,3,2,1는 사진에서 왼쪽에 행 으로 나타납니다 7,8,9,10,11. 그래서 우리는 12 행과 그림 숫자 합이 우리는 또한 확인 행에 세 개의 공간보다는 아무것도 그릴 수 없습니다 여부를 확인 0하고 6- 우측 박쥐 슬롯은 방망이를 그릴 것입니다, 우리는 그 중심까지 엉망이되지해야합니다.

기음#, 615 582 337 바이트

이것은 이것들 중 하나에 대한 나의 첫 번째 시도 (여전히 읽을 수있는) 시도이므로 수백 바이트를 줄이는 제안을 기쁘게 환영합니다! 내 목록의 상단은 현재 달 배열을 만드는 더 짧은 방법입니다.

void M(){string[]m={"","      mmm","    mmmmmmm","   mmmmmmmmm","    mmmmmmm","      mmm",""};var b="^o^";for(int x=0;x<13;x++){var a=(string[])m.Clone();int n=x>6?12-x:x;int[] j={0,1,3,6};a[n]=!a[n].Contains("m")?"      "+b:x<=n?a[n]+b:new string(' ',j[Math.Abs(9-x)])+b+a[n].Replace(" ","");foreach(var c in a){Console.WriteLine(c);}}}

언 골프 (루프 포함)

class Program {
    public static string[] moon = new string[] { "               ", "      mmm      ", "    mmmmmmm    ", "   mmmmmmmmm   ", "    mmmmmmm    ", "      mmm      ", "               " };

    public static string bat = "^o^";

    static void Main(string[] args) {
        while (true) {
            Fly();
        }
    }

    static void Fly() {
        int times = (moon.Length * 2) - 1;
        for (int x = 0; x < times; x++) {
            string[] temp = (string[])moon.Clone(); //create a new array to maintain the original

            int index = x >= moon.Length ? times - x - 1 : x;

            if (!temp[index].Contains("m")) {
                temp[index] = new string(' ', 6) + bat + new string(' ', 6);
            } else if (x <= index) {
                int lastM = temp[index].LastIndexOf('m') + 1;
                temp[index] = temp[index].Insert(lastM, bat);
            } else {
                int firstM = temp[index].IndexOf('m');
                char[] src = temp[index].ToCharArray();
                int i = firstM - bat.Length;
                src[i] = bat[0];
                src[i + 1] = bat[1];
                src[i + 2] = bat[2];

                temp[index] = new string(src);
            }

            for (int y = 0; y < temp.Length; y++) {
                Console.WriteLine(temp[y]);
            }
            Thread.Sleep(100);
            Console.Clear();
        }            
    }
}

편집하다:

배열 선언에서 후행 공백을 제거하여 21 바이트를 제거했습니다. 15 자 너비의 격자 대신 각 행은 박쥐가 들어갈 수있을만큼 넓습니다. Main()선언 에서 불필요한 문자열 [] args에 대해 다른 12 개를 제거했습니다 .

편집 2 :

245 바이트를 꺼내어 대부분의 논리를 다시 작성했습니다! 의견에서 제안 된 변경 사항을 포함합니다. 감사!

주석에서이를 M()이전 Main()방법 대신 함수로 변환 했으므로 이제 외부에서 호출해야합니다.

파이썬 2, 299 300 290 270 바이트

270까지 골프를하면서 약간의 골프 경험을 얻었습니다.

참조 구현은 321 320 330 바이트 감소했습니다. 예쁘거나 우아하지 않습니다. 무차별 대입 문자열과 목록 슬라이싱을 사용하십시오. 바이트 카운트를 줄이는 것이 재미 있었지만 심각한 경쟁자에게는 그 접근법이 완전히 잘못되었다고 생각합니다.

이 답변이 진지하게 받아 들여질 것이라고는 생각하지 않으므로 다운 보트를 사용하지 마십시오. 나는 질문에서 참조 구현을 골프화하려고 노력한다고 말했고 이것이 정확히 맞습니다. 재미를 위해 게시했습니다.

c,e,n=' ','m','\n';f,g=c*9+e*3+c*9,c*7+e*7+c*7;h=9,12;i=12,15;j=6,9;k=13,17;l=4,7;m=c*21,f,g,c*6+e*9+c*6,g,f,c*21;p=h,i,k,(15,18),k,i,h,j,l,(3,6),l,j,h;w=0
for z in map(int,'0123456543210'):print n.join(m[:z])+n+m[z][:p[w][0]]+'^o^'+m[z][p[w][1]:]+n+n.join(m[z+1:]);w+=1

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

루비, 164156 바이트

puts Zlib.inflate Base64.decode64 "eNqlkrUVAAEMQvtMcZP9DfLYvzo3qhNSxQ2GVRC1ad29ar1JXaoHbul16Yig+p6BCKqtFBFU+1IE1famoHrX/jZBvN8e8f5tiE94Ib4SBREwNKH5BNJy2QM="

매우 간단한 프로그램입니다. 더 많은 일을 할 수 있습니다. 의견에 팁을 남겨주세요.

/// , 205 바이트

/*/\/\///B/^o^*9/         
*M/mmm*N/MM*O/   *0/OO*n/

*1/O Nm0
*2/NM0
*3/0M9*4/1O2*7/13n*5/34/0B9570MB0
473O NmBO 
O2731ONMBO
75O NmBO 
3n510MB0n
5130B9n51OBM9n5 BNm0 
3n31B273 BNm0 
O27OBM9470B90M0O
410MO

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

후행 공간이 많이 필요하지 않은 경우에만 ...

볼거리, 223 바이트

이것은 InterSystems Cache Mumps를 사용하고 있습니다-루프 주위에 중괄호를 허용하여 한 줄의 중첩 루프에 편리합니다.

S X="09121415141209060403040609",R="097679",L="037973",S=-14 F Y=1:1:13 S S=S+2 F C=1:1:7 S F=$E(X,Y*2-1,Y*2),(M,T)="",$P(T," ",21)="" F A=1:1:$E(L,C){S M=M_"m"} S $E(T,$E(R,C))=M S:C=$S(Y<8:Y,1:Y-S) $E(T,F,F+2)="^o^" W T,!

아마 더 골프를 쳤을 수도 있고, 더 많은 시간이있을 때 그걸 가지고 놀 수도 있습니다. 또 다른 9 바이트를 추가하면 [H 1 W # '->가 추가되어 화면이 사라지는 애니메이션이 나타납니다.

S X="09121415141209060403040609",R="097679",L="037973",S=-14 F Y=1:1:13 S S=S+2 H 1 W # F C=1:1:7 S F=$E(X,Y*2-1,Y*2),(M,T)="",$P(T," ",21)="" F A=1:1:$E(L,C){S M=M_"m"} S $E(T,$E(R,C))=M S:C=$S(Y<8:Y,1:Y-S) $E(T,F,F+2)="^o^" W T,!

올바른 'do'문과 도트 루프가있는 애니메이션되지 않은 설명 버전 (애니메이션 버전)은 다음과 같습니다.

 S X="09121415141209060403040609"
 S R="097679",L="037973",S=-14              ; Initialize Variablex
 F Y=1:1:13 D                               ; Set up our main loop of 13 cels
 . S S=S+2                                  ; set up secondary counter, for start char.
 . H 1                                      ; halt for 1 second
 . W #                                      ; clear screen
 . F C=1:1:7 D                              ; set up our per-line loop
 . . S F=$E(X,Y*2-1,Y*2)                    ; set F to 2-digit "start of bat"
 . . S (M,T)=""                             ; set our "builder" lines to empty strings
 . . S $P(T," ",21)=""                      ; then reset our main 'line string' to 21 spaces.
 . . F A=1:1:$E(L,C){S M=M_"m"}             ; make our 'moon' text.
 . . S $E(T,$E(R,C))=M                      ; and insert our 'moon' into the empty line
 . . S:C=$S(Y<8:Y,1:Y-S) $E(T,F,F+2)="^o^"  ; find the start character for our 'bat' and insert.
 . . W T,!                                  ; and write the line and a CR/LF.

나는 무슨 일이 일어날 지 알기 위해 "압축 후 Base-64 인코딩"재즈를 시도했지만 인코딩 된 문자열은 프로그램 자체보다 약간 길어졌습니다! 압축 및 base64 인코딩에 대한 Cache의 시스템 호출은 상당히 길다. 예를 들어 base64를 디코딩하는 시스템 호출은 다음과 같습니다. $ System.Encryption.Base64Decode (STRING)

그 방법은 프로그램을 300 자 이상으로 '부 풀리게'할 것입니다.