Fondo

Aquí hay un desafío relacionado con Halloween.

Como habrás visto en mi último desafío, me gusta bastante lo que llamo animaciones de arte ascii, que no es solo dibujar un patrón, sino dibujar un patrón que progresa. Esta idea se me ocurrió después de que me pidieron hace un par de años animar una presentación (bastante aburrida) haciendo que murciélagos ascii al azar vuelen por la pantalla en Halloween. No hace falta decir que lo hice debidamente (me pagaban por ello) pero me hizo pensar que hay más en la vida que murciélagos aleatorios. Inspirado por esto, me gustaría proponer este desafío.

Reto

Haz que un murciélago vuele alrededor de la luna.

Aquí hay un murciélago:

^o^

Aquí está la luna:

     mmm         
   mmmmmmm       
  mmmmmmmmm      
   mmmmmmm       
     mmm     

Debe mostrar cada etapa del vuelo de los murciélagos (ver salida).

Entrada

Ninguna

Salida

      ^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   

Reglas

• Sin lectura de archivos externos o sitios web
• Puede enviar un programa completo o una función
• Los espacios adicionales y / o las nuevas líneas están bien para mí.
• Lagunas estándar prohibidas como de costumbre
• El murciélago debe terminar de nuevo en la cima de la luna.
• Si lo desea, siéntase libre de borrar la pantalla entre cuadros, sin embargo, esto no es un requisito. La salida como se muestra arriba está bien
• Como se trata de un código de golf, el ganador será la respuesta con el menor recuento de bytes, aunque cualquier respuesta es bienvenida

Muestra

Implementación de referencia en Python 2 totalmente sin golf (620 bytes pero solo para demostrar que se puede hacer. Puede jugarlo más tarde).

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

Resultado

Aunque @Jonathan obviamente gana en conteo de bytes con Jelly, voy a marcar la respuesta Brainfuck de @Oyarsa como la respuesta aceptada simplemente porque creo que cualquiera que pueda hacer algo como esto en un lenguaje tan loco merece +15 rep no importa cuantos bytes se necesitan Esto no es porque tenga ningún problema con los idiomas de golf. Vea mi respuesta a una pregunta sobre esto en meta si tiene alguna duda. Muchas gracias y respeto a todos los que contribuyeron en cualquier idioma.

Brainfuck, 690 bytes

Esta es mi primera vez jugando al golf, así que estoy seguro de que todavía hay mucho margen de mejora

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

Pruébalo en línea

Ungolfed algunos para facilitar la lectura:

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

Quería usar el hecho de que al agregar una nueva línea al comienzo, cada etapa se puede leer en ambas direcciones para obtener dos etapas diferentes, pero no pude encontrar una buena manera de hacerlo sin generar las seis etapas y media completas En seguida.

05AB1E , 69 62 60 bytes

Guardado 2 bytes gracias a Adnan .

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

Pruébalo en línea!

Explicación

3ð×…^o^)Ualmacena la lista [" ","^o^"]en X para su uso posterior.

13FNVbucles sobre las 13 etapas [0 .. 12] y almacena el índice de iteración actual en Y .

0379730vrecorre las filas de cada etapa,
donde N es el índice de la fila e y es el número actual de m .

Comenzamos agregando floor(5/(y+1))-(y==0)espacios a cada fila con ð5y>;ï-y_+×.

Luego determinamos si debería haber un murciélago o 3 espacios antes de los m .
Si (-N-Y)%12 == 0es cierto, agregamos un murciélago, de lo contrario 3 espacios.
Esta expresión ( N(Y-12%_Xè) colocará a los murciélagos en etapas 0,6-12.

Luego colocamos y m's con 'my×.

Ahora determinamos si debe haber un murciélago o 3 espacios después de las m .
El código NY-12%_y&Xècolocará un murciélago si ((N-Y)%12 == 0) and y!=0es verdadero, de lo contrario 3 espacios.
Esto colocará a los murciélagos en los escenarios 1-5.

Finalmente nos unimos a toda la fila en una cadena y de impresión con un salto de línea: J,.

JavaScript (ES6), 109 144 140 138 bytes

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

Versión animada

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>

Editar: ahorró un montón de bytes gracias a @RickHitchcock. La versión aburrida que solo devuelve las 13 cadenas multilínea en una matriz es 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^`))

Gelatina , 76 69 58 bytes

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

TryItOnline

¿Cómo?

⁾ 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 gracias a @Willem (use la variable en clugar de recorrer a 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' es el número de espacios antes de la luna (con 6 en la primera y última línea vacía, ya que el murciélago irá allí).

'0379730'es el número de 'm's en la luna en cada línea.

El zipdesempaqueta estos personajes en ay bhace la luna en el cielo m, con 3 espacios finales en cada línea.

La última línea atraviesa las posiciones del murciélago dentro de la luna y es efectivamente:

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

pero la tupla de posiciones está codificada como ordinales de caracteres imprimibles, con un agregado de 23 (ya que 9 no es imprimible). Esto aparece como " -;L[hrbQ@2' "y c=ord(b)-23se usa para extraer los valores.

Autovim , 85 81 bytes

Sin animación, probablemente todavía golfable ... Aún así, ¡no está mal para el nuevo chico de la cuadra! (autovim)

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

Para ejecutarlo:

autovim run ascii-bat.autovim -ni

Explicación

En resumen, dibujamos la luna, la copiamos y pegamos 12 veces, y usamos dos macros: una para agregar el murciélago a las primeras 7 lunas, y la otra para anteponer las últimas 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

Hice un pequeño programa en 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);

Aquí hay una versión más detallada:

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

Este es mi primer codegolf, si tienes alguna sugerencia, estoy feliz de escuchar :)

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)

Imprime la imagen. Cada línea tiene tres partes

• Un potencial murciélago a la izquierda
• Algún número de m's para la luna
• Un potencial murciélago a la derecha

Estas partes están concatenadas y centradas en una caja de tamaño 15 para espaciar. Para evitar que los murciélagos desplacen el centro, un murciélago perdido tiene tres espacios, la misma longitud. Para los murciélagos en la parte superior o inferior de la luna, se omite la ranura de la barra izquierda y se ocupa la ranura de la derecha.

Hay 91 líneas: una imagen de 7 líneas para cada una de las 13 imágenes. Estos se cuentan a través de divmod: como kcuenta de 0a 91, (k/7, k%7)va

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

Tomando el primer valor k/7como imagen y el segundo valor r=k%7como el número de fila dentro de la imagen, esto cuenta primero por imagen, luego por número de fila dentro de cada imagen, ambos indexados a 0.

El número de m's en la luna cambia con el número de fila r=k%7como [0,3,7,9,7,3,0]. En lugar de indexar esto, una fórmula fue más corta. Un conveniente grado de libertad es que el 0's puede ser cualquier valor negativo, ya que esto todavía da la cadena vacía cuando se multiplica por m. Jugar con una parábola y dividir el piso dio una fórmula r*(6-r)*8/5-5.

Ahora, buscamos seleccionar si dibujar un murciélago o un espacio vacío a cada lado. La matriz b=[' ','^o^']contiene las opciones.

El bate en la fila 0 en la imagen 0 (en la parte superior), en la fila 1 en la imagen 1 (a la derecha), en la fila 6 en la imagen 6 (en la parte superior). Por lo tanto, es fácil comprobar si aparece como la fila y el número de la imagen como si fueran iguales, k/7==r. Pero también necesitamos que la imagen 12 se parezca a la imagen 0, por lo que tomamos primero el número de imagen módulo 12.

A la izquierda es similar. El murciélago aparece a la izquierda en filas r=5,4,3,2,1en las imágenes 7,8,9,10,11. Por lo tanto, verificamos si la fila y el número de la imagen suman 12. También nos aseguramos de dibujar nada en lugar de tres espacios en las filas 0y 6, la ranura derecha del bate dibujará el bate, y no debemos estropear su centrado.

DO#, 615 582 337 bytes

Este es mi primer intento (todavía demasiado legible) en uno de estos, ¡así que con gusto agradeceré cualquier sugerencia para reducir unos cientos de bytes! La parte superior de mi lista en este momento es una forma más corta de crear la matriz de la luna.

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

Sin golf (¡incluye bucle!)

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

Editar:

Eliminó 21 bytes eliminando espacios finales en la declaración de matriz. En lugar de una cuadrícula de 15 caracteres de ancho, cada fila es lo suficientemente ancha como para que quepa el bate. Se eliminaron otros 12 para los argumentos innecesarios string [] en la Main()declaración.

Edición 2:

¡Reescribió la mayor parte de la lógica, eliminando 245 bytes! Incluye cambios sugeridos de los comentarios. ¡Gracias!

De los comentarios, convertí esto en una función en M()lugar del Main()método anterior , por lo que ahora, esto debe llamarse externamente.

Python 2, 299 300 290 270 bytes

Golfé hasta 270 después de haber ganado un poco más de experiencia en el golf.

La implementación de referencia se redujo en 321 320 330 bytes. No es bonita ni elegante. Solo usa cadena de fuerza bruta y corte de lista. Sin embargo, fue divertido obtener la cuenta regresiva del byte, pero creo que el enfoque fue completamente incorrecto para un competidor serio.

No espero que esta respuesta se tome en serio, así que por favor no hay votos negativos. Dije en la pregunta que intentaría jugar golf con la implementación de referencia y esto es exactamente eso. Recién publicado por diversión.

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

Pruébalo en línea!

Ruby, 164156 bytes

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

Programa muy simple. Se puede trabajar en más. Por favor, deje consejos en los comentarios.

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

Pruébalo en línea!

Solo si no necesito toneladas de espacios finales ...

Paperas, 223 bytes

Esto utiliza InterSystems Cache Mumps: permite llaves alrededor de los bucles, lo que lo hace útil para bucles anidados en una sola línea.

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

Probablemente podría jugar más al golf, y puedo jugar con eso cuando tenga más tiempo. Agregue otros 9 bytes y se animará [[debido a la adición de 'H 1 W #' -> que se detiene por un segundo y borra la pantalla:

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

Aquí hay una versión no escrita / explicada (de la versión de animación), con las declaraciones correctas de 'hacer' y bucles de puntos:

 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.

Traté de hacer el jazz "comprimir y luego codificar Base-64" solo para ver qué pasaría, ¡pero la cadena codificada terminó un poco más que el programa mismo! Eso, y el sistema de Cache requiere que la compresión y la codificación base64 sean bastante largas ... por ejemplo, aquí está la llamada al sistema para decodificar base64: $ System.Encryption.Base64Decode (STRING)

Ese método 'hincharía' el programa a más de 300 caracteres, creo ...