Arka fon

İşte Cadılar Bayramı ile ilgili bir meydan okuma.

Son meydan okumamdan da görmüş olabileceğiniz gibi, ascii sanat animasyonları olarak adlandırdıklarımdan çok hoşlanıyorum, bu sadece bir desen değil, ilerleyen bir desen çiziyor. Bu fikir bana birkaç yıl önce Cadılar Bayramı'ndaki ekran boyunca rastgele ascii yarasalar uçurarak (oldukça sıkıcı) bir sunumu canlandırmam istendi. Uygun bir şekilde mecbur olduğumu söylememe gerek yok (bunun için para alınıyordum) ama bu bana rastgele yarasalardan daha çok yaşam olduğunu düşündürdü. Bundan ilham alarak bu zorluğu teklif etmek istiyorum.

Meydan okuma

Ayın etrafında bir yarasa uçurun.

İşte bir yarasa:

^o^

İşte ay:

     mmm         
   mmmmmmm       
  mmmmmmmmm      
   mmmmmmm       
     mmm     

Yarasalar uçuşunun her aşamasını göstermelisiniz (çıktıya bakınız).

Giriş

Yok

Çıktı

      ^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   

kurallar

• Harici dosyalardan veya web sitelerinden okuma yok
• Tam bir program veya bir işlev gönderebilirsiniz
• Ekstra boşluklar ve / veya yeni satırlar bana göre iyi durumda
• Standart boşluklar her zamanki gibi yasaklandı
• Yarasa ayın tepesinde bitmeli
• Lütfen bu bir gereklilik değilse, isterseniz çerçeveler arasındaki ekranı temizlemek için çekinmeyin. Yukarıda gösterildiği gibi çıktı iyi
• Bu kod golf olduğu için, kazanan her ne kadar açık olsa da, en düşük bayt sayısına sahip cevap olacaktır.

Numune

Tamamen ungolfed Python 2'de referans uygulaması (620 bayt, ancak bunun yapılabileceğini kanıtlamak için. Daha sonra golf oynayabilir).

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

Sonuç

Her ne kadar @Jonathan, Jelly ile bayt sayımında açıkça kazansa da, @Oyarsa'dan Brainfuck'ın cevabını sadece kabul edilen cevap olarak işaretleyeceğim çünkü bunun gibi çılgın bir dilde gerçekten böyle bir şey yapabilecek birinin +15 rep almayı hak ettiğini düşünüyorum kaç bayt alır. Bunun sebebi golf dilleriyle ilgili herhangi bir sorunum olmadığı için değil. Bu ilgili soruya cevabım bakın meta Eğer herhangi bir şüpheniz varsa. Herhangi bir dilde katkıda bulunan herkese çok teşekkürler ve saygı duyuyorum.

Brainfuck, 690 Bayt

Bu benim ilk golf oynamam, bu yüzden hala geliştirilecek çok yer olduğuna eminim.

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

Çevrimiçi deneyin

Okunabilirlik için bazı Ungolfed:

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

Başlangıca yeni bir satır ekleyerek, her aşamada iki farklı aşama elde etmek için her iki yönde de okunabilir, ancak tam altı buçuk aşamayı oluşturmadan bunu yapmanın iyi bir yolunu bulamadım gerçeğini kullanmak istedim. bir kerede.

05AB1E , 69 62 60 bayt

Adnan sayesinde 2 bayt kaydedildi .

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

Çevrimiçi deneyin!

açıklama

3ð×…^o^)UListeyi daha sonra kullanmak [" ","^o^"]üzere X'te saklar .

13FNV13 aşamada döngüler [0 .. 12] ve geçerli yineleme indeksini Y olarak kaydeder .

0379730vN , her satırın satırları üzerinde döngü yapar;
burada N , satır dizinidir ve y , geçerli m sayısıdır .

floor(5/(y+1))-(y==0)Her satıra boşluk ekleyerek başlıyoruz ð5y>;ï-y_+×.

Bir yarasa ya önce 3 boşluk olmalıdır edip etmediğini belirlemek m en .
Eğer (-N-Y)%12 == 0doğruysa bir yarasa veya 3 boşluk ekleriz.
Bu ifade ( N(Y-12%_Xè), yarasaları aşamalar halinde yerleştirir 0,6-12.

Sonra yerleştirmek y m en ile 'my×.

Bir yarasa ve sonrasında 3 boşluk olmalıdır Şimdi eğer biz belirlemek m en .
Kod doğruysa baska 3 boşluk NY-12%_y&Xèyarasa yerleştirir ((N-Y)%12 == 0) and y!=0.
Bu yarasaları aşamalara yerleştirir 1-5.

Sonunda bir dizeye tüm satır katılmak ve bir satır ile yazdırın: J,.

JavaScript (ES6), 109 144 140 138 bayt

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

Animasyonlu sürüm

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 bayt

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>

Düzenleme: @RickHitchcock sayesinde bir sürü bayt kaydedildi. Bir dizideki 13 çok satırlı dizgiyi yalnızca döndüren sıkıcı sürüm 132 131 bayttır:

_=>[...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 bayt

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

TryItOnline

Nasıl?

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

@Willem sayesinde -2 bayt ( ca ile döngü yerine değişken kullanın 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' aydan önceki boşluk sayısıdır (yarasalar oraya gideceği için boş ilk ve son satırlarda 6 ile).

'0379730''m'her satırdaki aydaki s sayısıdır .

zipBu karakterleri açar ave bve gökyüzünde ay oluşturur mher satırda 3 arka boşluklu.

Son satır daha sonra aydaki yarasanın pozisyonlarını geçer ve etkilidir:

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

ancak pozisyon dizisi yazdırılabilir karakterlerin sıraları olarak kodlanmıştır, 23 eklenmiştir (çünkü 9 yazdırılamaz). Bu şekilde çıkar " -;L[hrbQ@2' "ve c=ord(b)-23değerleri çıkarmak için kullanılır.

Autovim , 85 81 bayt

Animasyon yok, muhtemelen hala golf oynamaktadır ... Yine de, bloktaki yeni çocuk için fena değil! (Autovim)

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

Çalıştırmak için:

autovim run ascii-bat.autovim -ni

açıklama

Kısacası, ayı çizer, 12 kez kopyalayıp yapıştırabilir ve iki makro kullanırız: biri ilk 7 aydaki yarasayı eklemek, diğeri son 6'yı hazırlamak için.

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

PHP'de küçük bir program yaptım:

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

İşte daha ayrıntılı bir versiyon:

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

Bu benim ilk kod yazıcım, herhangi bir öneriniz varsa, duymaktan memnuniyet duyarım :)

Python 2, 112 bayt

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)

Resmi yazdır Her çizginin üç bölümü vardır

• Soldaki potansiyel bir yarasa
• mAy için bir miktar
• Sağdaki potansiyel bir yarasa

Bu parçalar birleştirme ve boşluk için 15 boyutunda bir kutuda ortalanmıştır. Yarasaların merkeze kaymasını önlemek için, eksik bir yarasa aynı uzunlukta üç boşluktur. Ayın üstündeki veya altındaki yarasalar için, sol çubuk yuvası çıkar ve sağ yuva işgal edilir.

91 satır vardır: 13 resmin her biri için 7 satırlık bir resim. Bunlar divmod aracılığıyla yukarı sayılır: As kgelen sayımlar 0için 91, (k/7, k%7)gider

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

İlk değer k/7resim olarak ve ikinci değer r=k%7resim içindeki satır sayısı olarak alındığında, önce resim tarafından, sonra her resimdeki satır sayısıyla sayılır, her ikisi de 0 indekslenir.

Sayısı m'satır numarası ay değişir s r=k%7olarak [0,3,7,9,7,3,0]. Buna endekslemek yerine, bir formül daha kısaydı. Uygun bir serbestlik derecesi, bununla 0çarpıldığında boş dizgiye verdiği için herhangi bir negatif değer olabilir m. Bir parabol ve kat bölücü ile uğraşarak bir formül verdi r*(6-r)*8/5-5.

Şimdi, her iki tarafa da bir yarasa mı yoksa boş bir alan mı çizileceğini seçiyoruz. Dizi b=[' ','^o^']seçenekleri içerir.

0 satırındaki yarasa resim 0'da (üstte), 1. satırda 1 (sağda), 6. sırada 6'da (üstte). Böylece satır ve resim sayısının eşit görünüp görünmediğini kontrol etmek kolaydır k/7==r. Ama ayrıca resim 0'a benzemek için resim 12'ye ihtiyacımız var, bu yüzden önce resim numarasını modulo 12 çekelim.

Solda benzer. Yarasa sıralar halinde solda görünen r=5,4,3,2,1fotoğraflarda 7,8,9,10,11. Yani, biz 12'ye satır ve resim numarası toplamı Ayrıca emin olun satırlarda üç boşluk yerine bir şey çizmek olmadığını kontrol 0ve 6- sağ yarasa yuvası yarasa çekecek ve biz ortalanması kadar karışıklık olmamalıdır.

C #, 615 582 337 bayt

Bu benim ilk (hala çok okunabilir) denemelerimden biri, bu yüzden birkaç yüz baytlık tıraş için herhangi bir önerinizi memnuniyetle memnuniyetle kabul ederim! Şu an listemin en üstünde, ay dizisini oluşturmanın daha kısa bir yolu var.

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 (döngü içerir!)

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

Düzenle:

Dizi bildiriminde sondaki boşlukları kaldırarak 21 bayt aldı. 15 karakter genişliğinde bir ızgara yerine, her satır yalnızca yarasanın sığması için yeterince geniş. Gereksiz dize [] Main()bildirgesindeki args için bir tane daha 12 kaldırıldı .

Düzenleme 2:

Mantığın çoğunu 245 bayt alarak yeniden yazdım! Yorumlardaki önerilen değişiklikleri içerir. Teşekkürler!

Yorumlardan, bunu M()önceki Main()yöntem yerine bir işleve çevirdi - şimdi, bunun harici olarak çağrılması gerekiyor.

Python 2, 299 300 290 270 bayt

270'e kadar golf oynayarak biraz daha golf deneyimi yaşadım.

Referans uygulaması 321 320 330 byte tarafından düşürüldü . Güzel ya da şık değil. Sadece kaba kuvvet dizesini ve liste dilimlemeyi kullanır. Bayt'ı geri saymak çok eğlenceliydi ama bence ciddi bir rakip için başlangıç ​​yaklaşımı tamamen yanlıştı.

Bu cevabın ciddiye alınmasını beklemiyorum, bu yüzden lütfen oy kullanmayın. Referans uygulamasında golf oynamaya çalışacağımı ve bunun aynen böyle olduğunu sordum. Sadece eğlence için gönderildi.

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

Çevrimiçi deneyin!

Ruby, 164 156 bayt

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

Çok basit bir program. Daha fazlası üzerinde çalışılabilir. Lütfen yorumlarda ipucu bırakın.

/// , 205 bayt

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

Çevrimiçi deneyin!

Sadece tonlarca boşluk bırakmaya ihtiyacım olmasaydı ...

Kabakulak, 223 Bayt

Bu, InterSystems Önbellek Kabakulaklarını kullanıyor - tek bir çizgide iç içe döngüler için kullanışlı kılan döngülerin etrafındaki diş tellerine izin veriyor.

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

Muhtemelen daha çok golf oynayabilir ve daha fazla zamanım olduğunda bununla oynayabilirim. 9 bayt daha eklediğinizde, animasyon [[H 1 W # '-> eklenmesi nedeniyle bir saniye durup ekranı temizler.)

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

İşte doğru 'do' ifadeleri ve nokta döngülerinin olduğu bir ungolfed / açıklanan versiyon (animasyon versiyonunun):

 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.

Sadece ne olacağını görmek için "sıkıştırdıktan sonra Base-64 kodlaması" cazını yapmaya çalıştım, ancak kodlanmış dize programın kendisinden biraz daha uzun sürdü! Bu, ve Cache sistemi sıkıştırma çağrısı ve base64 kodlaması oldukça uzun ... örneğin, işte base64 kodunu çözmek için sistem çağrısı: $ System.Encryption.Base64Decode (STRING)

Bu yöntem programı 300'den fazla karaktere şişirecek, sanırım ...