Contexte

Voici un défi lié à Halloween.

Comme vous avez pu le constater lors de mon dernier défi, j'aime beaucoup ce que j'appelle des animations artistiques ascii. Il ne s'agit pas simplement de dessiner un motif, mais de dessiner un motif qui progresse. Cette idée m'est venue après qu'on m'a demandé, il y a quelques années, d'agrémenter une présentation (plutôt ennuyeuse) en faisant voler des chauves-souris ascii au hasard sur l'écran à l'Halloween. Inutile de dire que je suis obligé (on me payait pour cela) mais cela me faisait penser qu'il y a plus dans la vie que des chauves-souris aléatoires. Inspiré par cela, je voudrais proposer ce défi.

Défi

Faites voler une chauve-souris autour de la lune.

Voici une batte:

^o^

Voici la lune:

     mmm         
   mmmmmmm       
  mmmmmmmmm      
   mmmmmmm       
     mmm     

Vous devez montrer chaque étape du vol des chauves-souris (voir le résultat).

Contribution

Aucun

Sortie

      ^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   

Règles

• Pas de lecture de fichiers externes ou de sites Web
• Vous pouvez soumettre un programme complet ou une fonction
• Les espaces supplémentaires et / ou les nouvelles lignes me conviennent
• Lacunes standard interdites comme d'habitude
• La chauve-souris doit finir au sommet de la lune
• N'hésitez pas à vider l'écran entre les images si vous le souhaitez, mais ceci n'est pas obligatoire. Comme indiqué ci-dessus, la sortie est bonne
• S'agissant d'un code de golf, le gagnant sera la réponse avec le nombre d'octets le plus faible, bien que toute réponse soit la bienvenue.

Échantillon

Implémentation de référence en Python 2 totalement non-golfé (620 octets mais juste pour prouver que cela est possible. Pourrons le jouer plus tard).

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

Résultat

Bien que @Jonathan gagne évidemment sur le nombre d'octets avec Jelly, je vais marquer la réponse Brainfuck de @Oyarsa comme la réponse acceptée, tout simplement parce que je pense que quiconque peut réellement faire quelque chose comme cela dans un langage aussi fou mérite +15 représentants peu importe combien d'octets cela prend. Ce n'est pas parce que j'ai aucun problème avec les langues de golf. Voir ma réponse à une question à ce sujet sur la méta si vous avez des doutes. Merci beaucoup et respect à tous ceux qui ont contribué dans n'importe quelle langue.

Brainfuck, 690 octets

C'est la première fois que je joue au golf, alors je suis sûr qu'il y a encore beaucoup à faire.

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

Essayez-le en ligne

Ungolfed certains pour la lisibilité:

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

Je voulais utiliser le fait qu'en ajoutant une nouvelle ligne au début, chaque étape peut être lue dans les deux sens pour obtenir deux étapes différentes, mais je ne pouvais pas trouver un moyen de le faire sans générer les six étapes et demie complètes. immediatement.

05AB1E , 69 62 60 octets

Sauvegardé 2 octets grâce à Adnan .

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

Essayez-le en ligne!

Explication

3ð×…^o^)Ustocke la liste [" ","^o^"]dans X pour une utilisation ultérieure.

13FNVdes boucles au cours des 13 étapes [0 .. 12] et stocke l'indice d'itération actuelle Y .

0379730vdes boucles sur les lignes de chaque étage,
où N est l'indice de ligne et y est le nombre actuel de m de .

Nous commençons par ajouter des floor(5/(y+1))-(y==0)espaces à chaque ligne avec ð5y>;ï-y_+×.

Nous déterminons ensuite s'il doit y avoir une chauve-souris ou 3 espaces avant les m .
Si (-N-Y)%12 == 0est vrai, nous ajoutons une batte, sinon 3 espaces.
Cette expression ( N(Y-12%_Xè) placera les chauves-souris par étapes 0,6-12.

Ensuite, nous plaçons y m avec 'my×.

Maintenant, nous déterminons s'il doit y avoir une chauve-souris ou 3 espaces après les m .
Le code NY-12%_y&Xèplacera une batte si ((N-Y)%12 == 0) and y!=0est vrai, sinon 3 espaces.
Cela placera les chauves-souris sur les scènes 1-5.

Enfin , nous joignons la ligne entière dans une chaîne et imprimer avec une nouvelle ligne: J,.

JavaScript (ES6), 109 144 140 138 octets

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

Version animée

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 octets

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>

Edit: Sauvegardé un tas d'octets grâce à @RickHitchcock. La version ennuyeuse qui ne retourne que les 13 chaînes multilignes d'un tableau est de 132 à 131 octets:

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

Gelée , 76 69 58 octets

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

TryItOnline

Comment?

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

-2 octets grâce à @Willem (utilisez la variable cplutôt que de boucler 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' est le nombre d'espaces avant la lune (avec 6 sur les première et dernière lignes vides, car la chauve-souris y ira).

'0379730'est le nombre de 'm's dans la lune sur chaque ligne.

Le zipdéballe ces personnages dans aet bfait la lune dans le ciel m, avec 3 espaces de fuite sur chaque ligne.

La dernière ligne traverse ensuite les positions de la chauve-souris dans la lune et est effectivement:

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

mais le tuple de positions est codé comme les ordinaux des caractères imprimables, avec un 23 ajouté (puisque 9 n'est pas imprimable). Cela sort " -;L[hrbQ@2' "et c=ord(b)-23sert à extraire les valeurs.

Autovim , 85 81 octets

Pas d'animation, probablement encore golfable ... Pourtant, pas mal pour le nouveau venu! (autovim)

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

Pour l'exécuter:

autovim run ascii-bat.autovim -ni

Explication

En bref, nous dessinons la lune, la copions et la collons 12 fois, et utilisons deux macros: l’une pour ajouter la chauve-souris sur les 7 premières lunes, l’autre pour préfixer les 6 dernières.

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

J'ai fait un petit programme 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);

Voici une version plus verbeuse:

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

Ceci est mon premier codegolf, si vous avez une suggestion, je suis heureux de l'entendre :)

Python 2, 112 octets

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)

Imprimez la photo. Chaque ligne a trois parties

• Une chauve-souris potentielle à gauche
• Un certain nombre de mpour la lune
• Une chauve-souris potentielle à droite

Ces pièces sont concaténées et centrées dans une boîte de taille 15 pour les espacer. Pour éviter que les chauves-souris ne se déplacent au centre, une chauve-souris manquante a trois espaces, la même longueur. Pour les chauves-souris situées au-dessus ou au-dessous de la lune, la fente à gauche est omise et la fente à droite est occupée.

Il y a 91 lignes: une image de 7 lignes pour chacune des 13 images. Celles-ci sont comptées via divmod: Comme kcompte de 0à 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)

En prenant la première valeur k/7pour être l'image et la seconde valeur r=k%7comme numéro de ligne dans l'image, cela compte d'abord par image, puis par numéro de ligne dans chaque image, les deux indexés à 0.

Le nombre de mdans la lune change avec le numéro de ligne r=k%7comme [0,3,7,9,7,3,0]. Plutôt que d'indexer dans ceci, une formule était plus courte. Un degré de liberté commode consiste en ce que le 0'peut être n'importe quelle valeur négative, car cela donne toujours la chaîne vide multipliée par m. Le fait de jouer avec une parabole et de diviser le sol a donné une formule r*(6-r)*8/5-5.

Nous allons maintenant choisir de dessiner une batte ou un espace vide de chaque côté. Le tableau b=[' ','^o^']contient les options.

La chauve-souris de la ligne 0 de la photo 0 (en haut), de la ligne 1 de la photo 1 (à droite) et de la ligne 6 de la photo 6 (en haut). Il est donc facile de vérifier si le numéro de ligne et le numéro d’image sont égaux k/7==r. Mais nous avons aussi besoin de l'image 12 pour ressembler à l'image 0, nous prenons donc d'abord le numéro d'image modulo 12.

A gauche c'est pareil. La chauve-souris apparaît à gauche en lignes r=5,4,3,2,1dans les images 7,8,9,10,11. Donc, nous vérifions si le nombre de lignes et d’images est égal à 12. Nous nous assurons également de ne rien dessiner au lieu de trois espaces sur les lignes 0et 6- le logement de batte droit dessinera le bâton, et nous ne devons pas gâcher son centrage.

C # 615 582 337 octets

C’est ma première tentative (encore trop lisible) de l’une d’entre elles. C’est pourquoi je me ferai un plaisir d’apprécier toute suggestion visant à supprimer quelques centaines d’octets! En ce moment, le haut de ma liste est un moyen plus rapide de créer le tableau lunaire.

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 (comprend la boucle!)

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

Modifier:

A supprimé 21 octets en supprimant les espaces de fin dans la déclaration de tableau. Au lieu d'une grille de 15 caractères de large, chaque ligne est seulement assez large pour que la batte puisse tenir. Suppression d'un autre 12 pour la chaîne inutile [] args dans la Main()déclaration.

Edit 2:

Réécrit l'essentiel de la logique en supprimant 245 octets! Inclut les modifications suggérées à partir des commentaires. Merci!

D'après les commentaires, cela est devenu une fonction M()au lieu de la Main()méthode précédente - alors maintenant, il faut l'appeler de manière externe.

Python 2, 299 300 290 270 octets

Golfé à 270 ayant acquis un peu plus d'expérience de golf.

Implémentation de référence modifiée par 321 320 330 octets. Pas joli ou élégant. Utilise simplement une chaîne de force brute et le découpage de liste C'était amusant de compter le nombre d'octets, mais je pense que l'approche était complètement fausse pour commencer avec un concurrent sérieux.

Je ne m'attends pas à ce que cette réponse soit prise au sérieux, alors s'il vous plaît, pas de votes négatifs. Dans la question, j’ai dit que j’essaierais d’incorporer la mise en œuvre de référence et c’est exactement cela. Juste posté pour le plaisir.

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

Essayez-le en ligne!

Ruby, 164 156 octets

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

Programme très simple. Peut être travaillé sur plus. S'il vous plaît laissez des conseils dans les commentaires.

/// , 205 octets

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

Essayez-le en ligne!

Seulement si je n'avais pas besoin de tonnes d'espaces de fuite ...

Oreillons, 223 octets

Cela utilise InterSystems Cache Mumps - il permet des accolades autour des boucles, ce qui le rend pratique pour les boucles imbriquées sur une seule ligne.

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

Je pourrais probablement jouer davantage au golf, et je pourrais jouer avec cela quand j'ai plus de temps. Ajoutez 9 autres octets et il sera animé [[en raison de l'ajout du 'H 1 W #' -> qui s'arrête une seconde et efface l'écran:

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

Voici une version non expliquée / expliquée (de la version animée), avec les instructions correctes 'do' et les boucles de points:

 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.

J'ai essayé de faire du jazz "compresser puis encoder en Base-64" juste pour voir ce qui se passerait, mais la chaîne encodée s'est avérée un peu plus longue que le programme lui-même! Cela, et les appels système de Cache pour la compression et l'encodage en base64 sont assez longs ... par exemple, voici l'appel système pour décoder en base64: $ System.Encryption.Base64Decode (STRING)

Cette méthode "gonflerait" le programme à plus de 300 caractères, je pense ...