tło

Oto wyzwanie związane z Halloween.

Jak mogłeś zobaczyć z mojego ostatniego wyzwania , podoba mi się to, co nazywam animacjami sztuki ascii, to nie tylko narysowanie wzoru, ale narysowanie wzoru, który postępuje. Ten pomysł przyszedł mi do głowy po tym, jak kilka lat temu zostałem poproszony o ożywienie (raczej nudnej) prezentacji, sprawiając, że przypadkowe nietoperze ascii latały po ekranie w Halloween. Nie trzeba dodawać, że należycie się zobowiązałem (płacono mi za to), ale sprawiło, że pomyślałem, że w życiu jest coś więcej niż przypadkowe nietoperze. Zainspirowany tym chciałbym zaproponować to wyzwanie.

Wyzwanie

Spraw, aby nietoperz latał wokół Księżyca.

Oto nietoperz:

^o^

Oto księżyc:

     mmm         
   mmmmmmm       
  mmmmmmmmm      
   mmmmmmm       
     mmm     

Musisz pokazać każdy etap lotu nietoperzy (patrz dane wyjściowe).

Wkład

Żaden

Wydajność

      ^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   

Zasady

• Brak odczytu z zewnętrznych plików lub stron internetowych
• Możesz przesłać pełny program lub funkcję
• Dodatkowe spacje i / lub znaki nowej linii są dla mnie w porządku
• Standardowe luki zakazane jak zwykle
• Nietoperz musi skończyć z powrotem na szczycie księżyca
• Jeśli chcesz, możesz wyczyścić ekran między ramkami, ale nie jest to wymagane. Wyjście, jak pokazano powyżej, jest w porządku
• Ponieważ jest to kod golfowy, zwycięzca otrzyma odpowiedź o najniższej liczbie bajtów, chociaż jakakolwiek odpowiedź jest mile widziana

Próba

Odwołaj się do implementacji w całkowicie nie golfowym Pythonie 2 (620 bajtów, ale tylko po to, aby udowodnić, że da się to zrobić. Może później zagrać w golfa).

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

Wynik

Chociaż @Jonathan oczywiście wygrywa pod względem liczby bajtów z Jelly, oznaczę odpowiedź Brainfuck z @Oyarsa jako odpowiedź zaakceptowaną wyłącznie dlatego, że uważam, że każdy, kto może zrobić coś takiego w tak szalonym języku, zasługuje na +15 powtórzeń, bez względu na to ile bajtów to zajmuje. Nie dlatego, że mam problem z językami golfa. Jeśli masz jakiekolwiek wątpliwości, zobacz moją odpowiedź na pytanie dotyczące tego meta . Wielkie dzięki i szacunek dla wszystkich, którzy przyczynili się w jakimkolwiek języku.

Brainfuck, 690 bajtów

To mój pierwszy raz w golfa, więc jestem pewien, że jest jeszcze wiele do zrobienia

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

Wypróbuj online

Ungolfed niektóre dla czytelności:

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

Chciałem wykorzystać fakt, że dodając nowy wiersz na początku, każdy etap można odczytać w obu kierunkach, aby uzyskać dwa różne etapy, ale nie mogłem znaleźć dobrego sposobu na zrobienie tego bez wygenerowania pełnych sześciu i półetapów od razu.

05AB1E , 69 62 60 bajtów

Zaoszczędzono 2 bajty dzięki Adnan .

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

Wypróbuj online!

Wyjaśnienie

3ð×…^o^)Uprzechowuje listę [" ","^o^"]w X do późniejszego wykorzystania.

13FNVPętle ciągu 13 etapach [0 .. 12] i zapisuje bieżący indeks iteracji Y .

0379730vzapętla się nad rzędami każdego etapu,
gdzie N jest indeksem wiersza, a y jest bieżącą liczbą m .

Zaczynamy od dodania floor(5/(y+1))-(y==0)spacji do każdego wiersza za pomocą ð5y>;ï-y_+×.

Następnie określamy, czy przed m powinien być nietoperz, czy 3 spacje .
Jeśli (-N-Y)%12 == 0to prawda, dodajemy nietoperza, w przeciwnym razie 3 spacje.
To wyrażenie ( N(Y-12%_Xè) umieści nietoperze etapami 0,6-12.

Następnie kładziemy y M z 'my×.

Teraz określamy, czy po m ma być nietoperz, czy 3 spacje .
Kod NY-12%_y&Xèumieści nietoperza, jeśli ((N-Y)%12 == 0) and y!=0to prawda, w przeciwnym razie 3 spacje.
To umieści nietoperze na scenach 1-5.

Na koniec łączymy cały rząd na sznurku i wydrukować z nowej linii: J,.

JavaScript (ES6), 109 144 140 138 bajtów

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

Wersja animowana

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 bajtów

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>

Edycja: Zaoszczędź sporo bajtów dzięki @RickHitchcock. Nudna wersja, która po prostu zwraca 13 ciągów wielowierszowych w tablicy, ma 132 131 bajtów:

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

Galaretka , 76 69 58 bajtów

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

TryItOnline

W jaki sposób?

⁾ 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 bajtów

-2 bajty dzięki @Willem (użyj zmiennej czamiast zapętlać przezmap )

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' to liczba spacji przed księżycem (6 na pustych pierwszej i ostatniej linii, ponieważ nietoperz tam pojedzie).

'0379730' jest liczbą 'm' s na Księżycu w każdej linii.

zipRozpakowuje te znaki do aib i sprawia, że księżyc na niebie m, z 3 spacje na każdej linii.

Ostatnia linia następnie przemierza pozycje nietoperza na Księżycu i jest efektywna:

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

ale krotka pozycji jest zakodowana jako porządek znaków drukowalnych, z dodanym 23 (ponieważ 9 nie jest drukowalne). Wynika to jako " -;L[hrbQ@2' "i c=ord(b)-23służy do wyodrębnienia wartości.

Autovim , 85 81 bajtów

Brak animacji, prawdopodobnie nadal grywalnej ... Nadal nieźle jak na nowy dzieciak na bloku! (autovim)

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

Aby uruchomić:

autovim run ascii-bat.autovim -ni

Wyjaśnienie

Krótko mówiąc, rysujemy księżyc, kopiujemy go i wklejamy 12 razy, i używamy dwóch makr: jednego, aby dołączyć nietoperza do pierwszych 7 księżyców, a drugiego, aby poprzedzić ostatnie 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 bajtów

Zrobiłem mały program w 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);

Oto bardziej szczegółowa wersja:

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

To jest mój pierwszy codegolf, jeśli masz jakieś sugestie, cieszę się, że słyszę :)

Python 2, 112 bajtów

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)

Wydrukuj zdjęcie. Każda linia składa się z trzech części

• Potencjalny nietoperz po lewej stronie
• Niektóre liczby mdla księżyca
• Potencjalny nietoperz po prawej stronie

Części te są połączone i wyśrodkowane w pudełku o rozmiarze 15 w celu uzyskania odstępów. Aby uniknąć przesunięcia nietoperzy przez środek, brakujący nietoperz ma trzy pola o tej samej długości. W przypadku nietoperzy na księżycu lub poniżej księżyca lewy otwór paska jest pomijany, a prawy otwór jest zajęty.

Istnieje 91 linii: 7-liniowy obraz dla każdego z 13 zdjęć. Są one liczone za pomocą divmod: jak się kliczy od 0do 91, (k/7, k%7)idzie

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

Przyjmowanie pierwszej wartości k/7za zdjęcie i drugiej wartościr=k%7 jako numerem wiersza na obrazie, liczy się to najpierw według obrazu, a następnie według numeru wiersza na każdym zdjęciu, oba indeksowane 0.

Liczba mksiężyców zmienia się wraz z numerem rzędu r=k%7jako [0,3,7,9,7,3,0]. Zamiast indeksowania do tego formuła była krótsza. Dogodnym stopniem swobody jest to, że 0mogą mieć dowolną wartość ujemną, ponieważ nadal daje pusty ciąg po pomnożeniu m. Grzebanie w paraboli i dzielenie podłogi dało formułę r*(6-r)*8/5-5.

Teraz patrzymy na to, czy narysować nietoperza, czy puste miejsce po obu stronach. Tablica b=[' ','^o^']zawiera opcje.

Nietoperz w rzędzie 0 na zdjęciu 0 (u góry), w rzędzie 1 na zdjęciu 1 (po prawej), w rzędzie 6 na zdjęciu 6 (u góry). Łatwo więc sprawdzić, czy numer wiersza i obrazu jest równy,k/7==r . Ale potrzebujemy również obrazu 12, aby wyglądał jak obrazek 0, więc najpierw wybieramy numer zdjęcia modulo 12.

Po lewej jest podobnie. Nietoperz pojawia się po lewej stronie w rzędach r=5,4,3,2,1na zdjęciach 7,8,9,10,11. Sprawdzamy więc, czy liczba wiersza i obrazu wynosi 12. 12. Upewnijmy się również, że nie narysujemy nic poza trzema spacjami w rzędach 0i 6- odpowiednie miejsce na nietoperza narysuje nietoperza i nie wolno nam zepsuć jego centrowania.

DO#, 615 582 337 bajtów

To moja pierwsza (wciąż zdecydowanie zbyt czytelna) próba jednego z nich, dlatego chętnie przyjmę wszelkie sugestie, aby zgolić kilkaset bajtów! Na początku mojej listy jest teraz krótszy sposób na utworzenie tablicy księżyców.

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

Niegolfowany (zawiera pętlę!)

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

Edytować:

Wyjęto 21 bajtów, usuwając końcowe spacje w deklaracji tablicy. Zamiast siatki o szerokości 15 znaków, każdy rząd jest wystarczająco szeroki, aby zmieścił się nietoperz. Usunięto kolejne 12 dla niepotrzebnych argumentów string [] w Main()deklaracji.

Edycja 2:

Przepisałem większość logiki, usuwając 245 bajtów! Obejmuje sugerowane zmiany w komentarzach. Dzięki!

Z komentarzy zmieniono to w funkcję M()zamiast poprzedniej Main()metody - więc teraz trzeba to wywołać zewnętrznie.

Python 2, 299 300 290 270 bajtów

Grał w golfa do 270, mając nieco więcej doświadczenia w golfa.

Referencyjna implementacja zmniejszona o 321 320 330 bajtów. Nie ładna ani elegancka. Po prostu używa łańcucha brute force i krojenia listy. Fajnie było jednak odliczyć bajt, ale myślę, że podejście było całkowicie niewłaściwe na początku dla poważnego konkurenta.

Nie oczekuję, że ta odpowiedź zostanie potraktowana poważnie, więc proszę, nie wyrażajcie negatywnych opinii. Powiedziałem w pytaniu, że spróbuję zagrać w golfa implementację referencyjną i to jest dokładnie to. Właśnie wysłano dla zabawy.

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

Wypróbuj online!

Rubin, 164 156 bajtów

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

Bardzo prosty program. Można pracować nad więcej. Proszę zostawić wskazówki w komentarzach.

/// , 205 bajtów

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

Wypróbuj online!

Tylko gdybym nie potrzebował ton tylnych spacji ...

Świnka, 223 bajtów

Korzysta z Mumpów pamięci podręcznej InterSystems - pozwala na nawiasy klamrowe wokół pętli, dzięki czemu jest przydatny dla zagnieżdżonych pętli w jednej linii.

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

Prawdopodobnie można by grać w golfa więcej i mogę z tym grać, kiedy będę miał więcej czasu. Dodaj kolejne 9 bajtów, a będzie animowane [[z powodu dodania „H 1 W #” ->, który zatrzymuje się na sekundę i czyści ekran:

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

Oto niepoznana / objaśniona wersja (wersji animowanej) z prawidłowymi instrukcjami „do” i pętlami kropkowymi:

 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.

Próbowałem wykonać jazz „kompresuj, a następnie koduj Base-64”, aby zobaczyć, co się stanie, ale zakodowany ciąg skończył się nieco dłużej niż sam program! To, a systemowe odwołania Cache'a do kompresji i kodowania base64 są dość długie ... na przykład, oto systemowe wywołanie dekodowania base64: $ System.Encryption.Base64Decode (STRING)

Ta metoda „nadęje” program ponad 300 znaków, myślę ...