Hintergrund

Hier ist eine Halloween-bezogene Herausforderung.

Wie Sie vielleicht aus meiner letzten Herausforderung gesehen haben, gefällt mir das, was ich als ASCII-Kunstanimationen bezeichne, sehr gut, nämlich nicht nur ein Muster zu zeichnen, sondern ein fortschreitendes Muster zu zeichnen. Diese Idee kam mir, als ich vor ein paar Jahren gebeten wurde, eine (ziemlich langweilige) Präsentation zu beleben, indem ich an Halloween zufällige Ascii-Fledermäuse über den Bildschirm fliegen ließ. Unnötig zu sagen, dass ich gebührend verpflichtet war (ich wurde dafür bezahlt), aber es brachte mich auf den Gedanken, dass das Leben mehr beinhaltet als zufällige Fledermäuse. Davon inspiriert möchte ich diese Herausforderung vorschlagen.

Herausforderung

Lass eine Fledermaus um den Mond fliegen.

Hier ist eine Fledermaus:

^o^

Hier ist der Mond:

     mmm         
   mmmmmmm       
  mmmmmmmmm      
   mmmmmmm       
     mmm     

Sie müssen jede Phase des Fledermausflugs anzeigen (siehe Ausgabe).

Eingang

Keiner

Ausgabe

      ^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   

Regeln

• Kein Lesen von externen Dateien oder Websites
• Sie können ein vollständiges Programm oder eine Funktion einreichen
• Zusätzliche Leerzeichen und / oder Zeilenumbrüche sind von mir in Ordnung
• Standard-Schlupflöcher wie gewohnt verboten
• Die Fledermaus muss oben auf dem Mond enden
• Wenn Sie möchten, können Sie den Bildschirm zwischen den Frames löschen, dies ist jedoch keine Voraussetzung. Die oben gezeigte Ausgabe ist in Ordnung
• Da dies Codegolf ist, ist der Gewinner die Antwort mit der niedrigsten Byteanzahl, obwohl jede Antwort erwünscht ist

Probe

Referenzimplementierung in völlig ungolfed Python 2 (620 Bytes, aber nur um zu beweisen, dass es möglich ist. Kann es später Golf spielen).

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

Ergebnis

Obwohl @Jonathan offensichtlich bei der Anzahl der Bytes mit Jelly gewinnt, werde ich die Brainfuck-Antwort von @Oyarsa als akzeptierte Antwort markieren, nur weil ich denke, dass jeder, der so etwas in einer so verrückten Sprache tatsächlich kann, +15 Wiederholungen verdient, egal wie viele Bytes es braucht. Das liegt nicht daran, dass ich Probleme mit Golfsprachen habe. Wenn Sie irgendwelche Zweifel haben, lesen Sie meine Antwort auf eine diesbezügliche Frage auf meta . Vielen Dank und Respekt an alle, die in welcher Sprache auch immer beigetragen haben.

Brainfuck, 690 Bytes

Ich spiele zum ersten Mal Golf und bin mir sicher, dass es noch viel zu verbessern gibt

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

Probieren Sie es online aus

Ungolfed einige für die Lesbarkeit:

-[-[-<]>>+<]>-<<+++[>+++++++<-]>>>+>>-[<-->-------]<->++++++++>+>+++++>+>+++++>+>+++++++>+>+++++>+>+++++>+>++++++++>+>+>+>>+++[<++++++>-]<+>+>-->+>+>+
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

Ich wollte die Tatsache nutzen, dass durch Hinzufügen einer neuen Zeile am Anfang jede Stufe in beide Richtungen gelesen werden kann, um zwei verschiedene Stufen zu erhalten, aber ich konnte keinen guten Weg finden, dies zu tun, ohne die vollständigen sechseinhalb Stufen zu generieren auf einmal.

05AB1E , 69 62 60 Bytes

2 Bytes gespart dank Adnan .

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

Probieren Sie es online!

Erläuterung

3ð×…^o^)Uspeichert die Liste [" ","^o^"]in X zur späteren Verwendung.

13FNVSchleifen über die 13 Stufen [0 .. 12] und speichert die aktuelle Iterationsindex in Y .

0379730vSchleifen über die Zeilen jeder Stufe,
wobei N der Zeilenindex und y die aktuelle Anzahl von m ist .

Wir beginnen mit dem Hinzufügen von floor(5/(y+1))-(y==0)Leerzeichen zu jeder Zeile mit ð5y>;ï-y_+×.

Wir bestimmen dann, ob es eine Fledermaus oder 3 Felder vor dem m geben sollte .
Wenn dies (-N-Y)%12 == 0zutrifft, fügen wir eine Fledermaus hinzu, ansonsten 3 Felder.
Dieser Ausdruck ( N(Y-12%_Xè) platziert Fledermäuse in Stufen 0,6-12.

Dann legen wir y Ms mit 'my×.

Nun legen wir fest, ob es einen Schläger oder 3 Felder nach dem m geben soll .
Der Code setzt NY-12%_y&Xèeinen Schläger, wenn er ((N-Y)%12 == 0) and y!=0wahr ist, ansonsten 3 Leerzeichen.
Dadurch platzieren Sie die Fledermäuse auf den Bühnen 1-5.

Endlich haben wir die ganze Reihe in einen String verbinden und mit einem Newline drucken: J,.

JavaScript (ES6), 109 144 140 138 Byte

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

Animierte Version

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 Bytes

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>

Bearbeiten: Dank @RickHitchcock eine Menge Bytes gespeichert. Die langweilige Version, die nur die 13 mehrzeiligen Zeichenfolgen in einem Array zurückgibt, ist 132 131 Bytes:

_=>[...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^`))

Jelly , 76 69 58 Bytes

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

TryItOnline

Wie?

⁾ 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

Python 2, 146 144 138 Bytes

-2 Bytes dank @Willem (benutze die Variable canstatt eine Schleife durchlaufen zu lassen 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:])

repl.it

'6643466' ist die Anzahl der Felder vor dem Mond (mit 6 in der leeren ersten und letzten Zeile, da die Fledermaus dorthin geht).

'0379730'ist die Anzahl der 'm's im Mond in jeder Zeile.

Das zippackt diese Charaktere in aund bund macht den Mond zum Himmel m, mit 3 nachgestellten Leerzeichen in jeder Zeile.

Die letzte Linie durchquert dann die Positionen der Fledermaus im Mond und ist effektiv:

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

Das Tupel der Positionen wird jedoch als Ordnungszahl der druckbaren Zeichen mit einer zusätzlichen 23 codiert (da 9 nicht druckbar ist). Dies wird als " -;L[hrbQ@2' "ausgegeben und c=ord(b)-23zum Extrahieren der Werte verwendet.

Autovim , 85 81 Bytes

Keine Animation, wahrscheinlich noch golffähig ... Trotzdem nicht schlecht für das neue Kind auf dem Block! (autovim)

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

Um es auszuführen:

autovim run ascii-bat.autovim -ni

Erläuterung

Kurz gesagt, wir zeichnen den Mond, kopieren und fügen ihn 12 Mal ein und verwenden zwei Makros: eines zum Anhängen des Schlägers an die ersten 7 Monde, das andere zum Voranstellen der letzten 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 Bytes

Ich habe ein kleines Programm in PHP gemacht:

<?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);

Hier ist eine ausführlichere Version:

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

Dies ist mein erster Codegolf, wenn Sie einen Vorschlag haben, den ich gerne höre :)

Python 2, 112 Bytes

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)

Drucken Sie das Bild. Jede Zeile besteht aus drei Teilen

• Eine mögliche Fledermaus auf der linken Seite
• Einige mfür den Mond
• Eine mögliche Fledermaus auf der rechten Seite

Diese Teile sind verkettet und zur Beabstandung in einem Karton der Größe 15 zentriert. Um zu vermeiden, dass die Fledermäuse die Mitte verschieben, besteht ein fehlender Fledermaus aus drei gleich langen Feldern. Bei Fledermäusen über oder unter dem Mond wird der linke Balkenplatz weggelassen und der rechte Platz belegt.

Es gibt 91 Zeilen: ein 7-Zeilen-Bild für jedes der 13 Bilder. Diese werden über divmod hochgezählt: Wie kvon 0bis zählt 91, (k/7, k%7)geht

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

Nimmt man den ersten Wert k/7als Bild und den zweiten Wert r=k%7als Zeilennummer im Bild, zählt dies zuerst nach Bild und dann nach Zeilennummer in jedem Bild, beide mit 0-Index.

Die Anzahl mder Monds ändert sich mit der Zeilennummer r=k%7als [0,3,7,9,7,3,0]. Anstatt dies zu indizieren, war eine Formel kürzer. Ein geeigneter Freiheitsgrad besteht darin, dass das 0s ein beliebiger negativer Wert sein kann, da dies bei Multiplikation mit immer noch die leere Zeichenfolge ergibt m. Das Spielen mit einer Parabel und die Unterteilung des Bodens ergaben eine Formel r*(6-r)*8/5-5.

Nun schauen wir uns an, ob wir auf beiden Seiten eine Fledermaus oder ein leeres Feld zeichnen wollen. Das Array b=[' ','^o^']enthält die Optionen.

Die Fledermaus in Reihe 0 auf in Bild 0 (oben), in Reihe 1 in Bild 1 (rechts), auf in Reihe 6 in Bild 6 (oben). So ist es einfach zu überprüfen, ob die Zeilen- und Bildnummer gleich sind k/7==r. Wir brauchen aber auch Bild 12, um wie Bild 0 auszusehen, also nehmen wir zuerst die Bildnummer modulo 12.

Links ist es ähnlich. Die Fledermaus erscheint links in Reihen r=5,4,3,2,1in Bildern 7,8,9,10,11. Wir prüfen also, ob die Reihen- und Bildnummer 12 ergibt. Wir achten auch darauf, dass Sie nur drei Leerzeichen auf die Reihen 0und 6- den richtigen Schlägerschlitz setzen, um den Schläger zu zeichnen. Wir dürfen seine Zentrierung nicht durcheinander bringen.

C #, 615 582 337 Bytes

Dies ist mein erster (immer noch viel zu lesbarer) Versuch, also freue ich mich über Vorschläge, ein paar hundert Bytes zu entfernen! Ganz oben auf meiner Liste steht jetzt eine kürzere Möglichkeit, das Mond-Array zu erstellen.

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

Ungolfed (inklusive Schleife!)

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

Bearbeiten:

Entfernte 21 Bytes, indem die nachgestellten Leerzeichen in der Array-Deklaration entfernt wurden. Anstelle eines 15 Zeichen breiten Gitters ist jede Reihe nur so breit, dass der Schläger hineinpasst. Es wurden weitere 12 für die unnötigen Zeichenfolgen [] in der Main()Deklaration entfernt.

Bearbeiten 2:

Den größten Teil der Logik neu geschrieben und 245 Bytes herausgenommen! Enthält Änderungsvorschläge aus den Kommentaren. Vielen Dank!

Aus den Kommentaren wurde eine Funktion M()anstelle der vorherigen Main()Methode - daher muss diese jetzt extern aufgerufen werden.

Python 2, 299 300 290 270 Bytes

Golf bis 270, nachdem ich ein bisschen mehr Golferfahrung gesammelt habe.

Die Referenzimplementierung wurde um 321 320 330 Bytes reduziert . Nicht hübsch oder elegant. Verwendet nur Brute Force String und List Slicing. Es hat Spaß gemacht, den Byte-Countdown zu starten, aber ich denke, dass der Ansatz für einen ernsthaften Konkurrenten zunächst völlig falsch war.

Ich erwarte nicht, dass diese Antwort ernst genommen wird, also bitte keine Abstimmungen. Ich habe in der Frage gesagt, dass ich versuchen würde, die Referenzimplementierung zu spielen, und das ist genau das. Nur zum Spaß gepostet.

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

Probieren Sie es online!

Ruby, 164 156 Bytes

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

Sehr einfaches Programm. Kann weiter bearbeitet werden. Bitte hinterlassen Sie Tipps in den Kommentaren.

/// 205 Bytes

/*/\/\///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

Probieren Sie es online!

Nur wenn ich nicht Tonnen von Leerzeichen brauchte ...

Mumps, 223 Bytes

Hierbei werden InterSystems-Cache-Mumps verwendet. Sie ermöglichen geschachtelte Schleifen in einer einzigen Zeile.

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

Könnte wahrscheinlich mehr Golf spielen und ich kann damit spielen, wenn ich mehr Zeit habe. Füge weitere 9 Bytes hinzu und es wird animiert [[aufgrund des Hinzufügens von 'H 1 W #' -> das für eine Sekunde anhält und den Bildschirm löscht:

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

Hier ist eine ungolfed / EXPLAIN-Version (der Animationsversion) mit den korrekten 'do'-Anweisungen und Punktschleifen:

 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.

Ich habe versucht, den Jazz "Compress, dann Base-64-Codierung" zu machen, um zu sehen, was passieren würde, aber die codierte Zeichenfolge endete etwas länger als das Programm selbst! Das und die Systemaufrufe von Cache für die Komprimierung und Base64-Codierung sind ziemlich lang. Hier ist beispielsweise der Systemaufruf zum Decodieren von Base64: $ System.Encryption.Base64Decode (STRING)

Diese Methode würde das Programm auf über 300 Zeichen "aufblähen", denke ich ...