Siapa yang tidak suka film aksi dengan mobil berisik, terutama yang banyak tabrakan? Siapa yang tidak suka foto aksi dalam seni ascii?

Adegannya adalah:

Dua mobil mulai di sisi yang berlawanan dari jalan lurus (dengan 60 ruang antara). Mereka mulai mengemudi satu sama lain dengan kecepatan konstan. Mobil ke kiri drive pada 1 ruang per detik, dan yang ke kanan drive pada 2 ruang per detik.

Jelas, mobil-mobil tidak dapat saling melewati, jadi untuk n ≥ 20, adegan akan menjadi dua mobil yang jatuh dengan kap di posisi di mana kecelakaan itu terjadi.

Sebagai seorang pecinta film, saya ingin menghentikan adegan itu sesekali, hanya untuk menikmati keindahannya.

Diberikan bilangan bulat n(argumen fungsi atau STDIN), mewakili jumlah detik dari awal adegan, tampilkan adegan pada saat itu.

Ini adalah adegan awal, dengan 60 spasi di antara roda depan:

  __                                                                __
_/  \_                                                            _/  \_
o    o                                                            o    o

ini adalah adegan setelah 11 detik:

             __                               __
           _/  \_                           _/  \_
           o    o                           o    o

dan seperti inilah rupanya setelah tabrakan (perhatikan bahwa kap mesin sudah menyala setelah tabrakan):

                      __    __
                    _/  \/\/  \_
                    o    oo    o

Saya hanya tertarik menonton dua mobil menabrak, jadi spasi, baris baru, ++ tidak masalah.

Ini adalah kode golf, jadi kode terpendek dalam byte menang. Jawaban yang ditambahkan nanti masih bisa menang jika lebih pendek dari jawaban yang diterima saat ini.

CJam, 68 66 byte

liKe<:M"  __  _/  \_o    o"6/f{\S*1$+60M3*-S*@N}:+MK={58'/t59'\t}&

Cobalah online

Siapa pun yang melihat awal kode pasti akan liKemelakukannya!

Penjelasan:

li      Get input n and convert to integer.
Ke<     Cap n at 20.
:M      Save in variable M for multiple use later.
"  __  _/  \_o    o"
        Car (18 characters).
6/      Split into 3 lines of 6 characters.
f{      Map lines with parameter.
  \       Swap n to top.
  S*      Create string with n spaces for left margin.
  1$      Copy one car line to top. Keep original for second car
  +       Concatenate the spaces and car.
  60M3*-  Calculate 60-3*n, which is the amount of space between cars.
  S*      Create string with 60-3*n spaces.
  N       Add a newline.
}       End of line mapping.
:+      Concatenate all output pieces into single string.
MK=     Check if capped n is equal to 20.
{       If equal, replace hoods with crashed versions.
  58'/t   '/ at position 58.
  59'\t   '\ at position 59.
}&      End of conditional block for crashed hoods.

Labyrinth , 394 386 bytes

Saya dengan bangga memperkenalkan ...

<}74}}:23}29}59}}}}}}}:111_}}}}:::::::23_}:111
?                        @
:" }}_47}_95    3""""""""(
 _ :       }    _   }    {=}
 2 23_}29_ _    ;   :      \
 0       ; 3  +_( 3_"  60{ .{.{.
"-_95:}}"" 2  0 ) 2 "  _ _ {
""       _ :  2 _ ."(; } 3 .{
 ;_92}_47} :  _ 0    = : *  ;
           : "" 2 {.{{ . -""(
}}:59_}}:::: "";_ .    {  _ "
}             "   {.{.{.  32.
}}}_95:}}}}_20-

... Labyrinth esolang dua dimensi baru saya! Kode di atas tidak golf dengan sangat baik (ada 161 ruang dan 25 NOP, jadi tata letak yang lebih baik dapat mempersingkat ini banyak), tapi setidaknya saya berhasil menunjukkan bahwa bahasa tersebut dapat digunakan untuk tugas-tugas non-sepele. :)

Bagaimana itu bekerja

Pertama, ikhtisar singkat bahasa:

• Labirin beroperasi pada dua tumpukan, utama dan tambahan , yang dapat menampung bilangan bulat yang ditandatangani secara sewenang-wenang. Di bagian bawah kedua tumpukan ada nol yang tak terbatas.
• Perintah adalah karakter individu pada kisi 2D dan membentuk sebuah labirin (yaitu karakter yang tidak dikenal, terutama spasi, adalah dinding). "adalah NOP yang bukan dinding dan dapat membantu untuk mengisi jalur tertentu dalam kode. Berbeda dengan banyak bahasa 2D lainnya, ujung-ujungnya tidak membungkus.
• Instruksi penunjuk (IP) dimulai pada karakter non-dinding pertama (dalam urutan membaca) bergerak ke kanan. @mengakhiri program.
• Jika memungkinkan, IP mengikuti koridor (juga di sekitar tikungan). Jika IP memiliki banyak sel untuk dipindahkan, umumnya akan berbelok ke kiri jika bagian atas tumpukan utama negatif, bergerak lurus ke depan jika nol, atau berbelok ke kanan jika positif. Ketika IP menyentuh dinding, ia membalikkan arah. (Ada beberapa seluk-beluk lagi, tetapi mereka seharusnya tidak masalah untuk kode ini.) Ini adalah satu-satunya cara untuk menerapkan aliran kontrol.
• Terlepas dari perintah manipulasi aritmatika dan stack, kode sumber dapat dimodifikasi pada saat runtime dengan empat perintah >v<^yang akan menggeser baris atau kolom kode sumber secara siklus dengan satu sel. Baris atau kolom mana yang terpengaruh tergantung pada bagian atas tumpukan. Jika baris atau kolom IP sendiri bergeser, ia akan bergerak dengan bergeser. Ini memungkinkan untuk melompat dari satu tepi kode sumber ke yang lain.

Sekarang untuk tantangan khusus ini, berikut adalah ide umum dari algoritma:

• Dorong ujung mobil ke kap (yaitu / \_o oo o) ke tumpukan tambahan.
• Baca input dan tentukan apakah akan mendorong __atau /\berikutnya.
• Dorong sisa mobil (yaitu __ __ _/ \dan dua ruang utama) ke tumpukan tambahan.
• Jepit input ke nilai maksimum 20, sebut saja N ini .
• Sekarang lakukan 3 kali berikut:
  • Cetak N spasi.
  • Cetak 6 karakter tersimpan.
  • Cetak 60 - 3 * N spasi.
  • Cetak 6 karakter tersimpan.
  • Cetak baris baru.

Akhirnya, mari kita lihat beberapa bagian kode. IP dimulai di sudut kiri atas, pada perintah grid shifting. Bagian atas tumpukan utama adalah 0(yang digunakan sebagai indeks relatif), sehingga baris pertama digeser ke kiri, yang juga memindahkan IP ke ujung kanan grid. Sekarang baris pertama dijalankan dari kanan ke kiri, yang mendorong set karakter tetap pertama ke tumpukan tambahan:

}74}}:23}29}59}}}}}}}:111_}}}}:::::::23_}:111<

Pergeseran baris ini berguna untuk bermain golf saat Anda ingin memulai dengan sejumlah besar kode linier.

Selanjutnya kita membaca input dan mendorong kap yang benar:

?  
:" 
 _ 
 2 
 0       ;
"-_95:}}""
""       _
 ;_92}_47}

Bit di sebelah kiri dengan tiga NOP mengirimkan hasil negatif di sepanjang cabang atas dan hasil non-negatif di sepanjang cabang bawah. Di sebelah kanan mereka disatukan kembali.

Sekarang ikuti bagian linier besar lainnya (yang mungkin bisa banyak bermain golf dengan trik pengalihan baris lainnya):

   }}_47}_95 
   :       } 
   23_}29_ _ 
           3 
           2 
           : 
           : 
           : 
}}:59_}}:::: 
}
}}}_95:}}}}

Ini mendorong sisa mobil ke tumpukan tambahan.

Selanjutnya, kami menghitung min(20, input), yang mirip dengan cabang pertama:

                ;
              +_(
              0 )
              2 _
              _ 0
             "" 2
             "";_
              "  
           _20-

Akhirnya, kita memiliki loop yang berjalan tiga kali untuk mencetak garis. Setiap iterasi dari loop berisi dua loop kecil (3x3) untuk mencetak spasi, serta dua bagian untuk mencetak 6 karakter dari stack tambahan:

                         @
                3""""""""(
                _   }    {=}
                    :      \
                  3_"  60{ .{.{.
                  2 "  _ _ {
                  ."(; } 3 .{
                     = : *  ;
                  {.{{ . -""(
                  .    {  _ "
                  {.{.{.  32.

Satu trik bagus yang ingin saya perhatikan adalah .{.{.pada ujung kanan. Ini adalah jalan buntu, jadi selain dari .pada akhirnya kode dieksekusi dua kali, sekali maju dan sekali mundur. Ini memberikan cara yang rapi untuk memperpendek kode palindrom (tangkapannya adalah Anda perlu memastikan IP mengambil belokan yang benar ketika keluar dari jalan buntu lagi).

Python 2.7, 167 164 159 Bytes

n=input();s,x=60-3*n,min(n,20)
for e in['  _',"_/ ","o  "]:p=e+(e[::-1],(' \_',' \/')[s<1])['/'in e];print" "*x+p+" "*s+(p[-1]+p[1:-1]+p[0]).replace("//","\/")

Ini mengambil input dari stdin.
Demo di sini
Menguji ini -

$ ./cars.py
0
  __                                                                __  
_/  \_                                                            _/  \_
o    o                                                            o    o

$ ./cars.py
11
             __                               __  
           _/  \_                           _/  \_
           o    o                           o    o

$ ./cars.py
20
                      __    __  
                    _/  \/\/  \_
                    o    oo    o

R, 191 Bytes

Tentang sebaik yang saya bisa dapatkan sekarang. Mengambil detik dari STDIN dan kucing ke STDOUT.

n=scan();p=paste0;formals(p)$collapse='';cat(sprintf(c('%s  __  %s  __  ','%s_/  \\_%s_/  \\_','%s_/  \\/%s\\/  \\_','%so    o%so    o')[-3+(n<21)],p(rep(' ',n)),p(rep(' ',60-n*3))),sep='\n')

Penjelasan

# Get the input from STDIN.  Requires a single number 0-20
n=scan();
# alias paste0 and set collapse default to ''
p=paste0;
formals(p)$collapse='';
# output
cat(
    # sprintf to format the strings
    sprintf(
        # vector of strings to format                                                      picks which bonnet to remove
        c('%s  __  %s  __  ','%s_/  \\_%s_/  \\_','%s_/  \\/%s\\/  \\_','%so    o%so    o')[-3+(n<21)]
        # move left car by 1
        ,p(rep(' ',n))
        # move right car by 2
        ,p(rep(' ',60-n*3))
    )
,sep='\n')

Tes

> n=scan();p=paste0;formals(p)$collapse='';cat(sprintf(c('%s  __  %s  __  ','%s_/  \\_%s_/  \\_','%s_/  \\/%s\\/  \\_','%so    o%so    o')[-3+(n==20)],p(rep(' ',n)),p(rep(' ',60-n*3))),sep='\n')
1: 0
2: 
Read 1 item
  __                                                                __  
_/  \_                                                            _/  \_
o    o                                                            o    o
> n=scan();p=paste0;formals(p)$collapse='';cat(sprintf(c('%s  __  %s  __  ','%s_/  \\_%s_/  \\_','%s_/  \\/%s\\/  \\_','%so    o%so    o')[-3+(n==20)],p(rep(' ',n)),p(rep(' ',60-n*3))),sep='\n')
1: 5
2: 
Read 1 item
       __                                                 __  
     _/  \_                                             _/  \_
     o    o                                             o    o
> n=scan();p=paste0;formals(p)$collapse='';cat(sprintf(c('%s  __  %s  __  ','%s_/  \\_%s_/  \\_','%s_/  \\/%s\\/  \\_','%so    o%so    o')[-3+(n==20)],p(rep(' ',n)),p(rep(' ',60-n*3))),sep='\n')
1: 20
2: 
Read 1 item
                      __    __  
                    _/  \/\/  \_
                    o    oo    o
> 

CJam, 120 byte

q~20e<_["   "]*\[" _o"]\[" / " "_  " "_  " " \ " ]\[19>" /o"" _o"?]60 3 5$,*-["   "]*[0$," _o"" \o"?]3$[" _o"]+++++++zN*

Demo

Tidak Disatukan:

q~        e# Read the input
20e<      e# min(20, input) (let's call it N)
_         e# Duplicate the value on the stack
["   "]   e# Push 3 blank spaces
*         e# Create N arrays of 3 blank spaces
\         e# Swap the top two stack elements
[" _o"]   e# Push the " _o" string to stack
\         e# Swap the top two stack elements
[" / " "_  " "_  " " \ " ]
\         e#
[         e# If N is greater than 20 then push the array [" /o"],
  19      e# otherwise [" _o"]
  >
  " /o"
  " _o"
  ?
]
60        e# 60 is the maximum space between the two cars
3         e# 3 is the number of blocks covered per move
5$,       e# Take the 6th element from the stack (an array of size N)
*-        e# Compute the remaining blocks (60 - 3 * N)
["   "]   e# Add an array of 3 blank spaces
*         e# Multiply it to fit the remaining blocks
[0$," _o"" \o"?] e# Add the (broken?) front part of the second car
3$        e# Copy the middle part of the car
[" _o"]   e# Append the right side of the car
+++++++   e# Concatenate all arrays
z         e# Transpose the array
N*        e# Join the array using new lines

Demo

PHP, 160 155 byte

$f=str_repeat;echo$l=$f(' ',$s=min(max($argv[1],0),20)),"  __  ",
$m=$f(' ',$r=60-3*$s),"  __\n{$l}_/  \\",$r?_.$m._:'/\\',
"/  \\_\n{$l}o    o{$m}o    o\n";

Kode ditampilkan di sini pada 3 baris agar sesuai dengan tata letak kotak kode. Baris baru itu tidak diperlukan.

Kode yang tidak dipisahkan:

// The number of seconds, between (and including) 0 and 20
$sec  = min(max($argv[1], 0), 20);
$rest = 60 - 3 * $sec;

$left = str_repeat(' ', $sec);      // left padding
$mid  = str_repeat(' ', $rest);     // space in the middle
$c = $rest ? '_'.$mid.'_' : '/\\';

echo($left.'  __  '.$mid."  __\n");
echo($left.'_/  \\'. $c ."/  \\_\n");
echo($left.'o    o'.$mid."o    o\n");

Ia mendapatkan jumlah detik dari baris perintah (argumen pertama):

$ php -d error_reporting=0 action.php 11
             __                               __
           _/  \_                           _/  \_
           o    o                           o    o

Opsi PHP CLI -d error_reporting=0diperlukan untuk menyembunyikan beberapa pemberitahuan yang ditampilkan oleh PHP tentang konstanta yang tidak terdefinisi ( str_repeat, _) yang dikonversi menjadi string (2 byte disimpan untuk setiap pemberitahuan).

Satu byte tambahan dapat disimpan di PHP 7 dengan menekan inisialisasi $fpenggunaan pertama ( $m=($f=str_repeat)(...)); itu tidak dikompilasi di PHP 5.

Kasing uji dan beberapa teknik yang digunakan untuk mengecilkan kode dapat ditemukan di github .

Memperbarui:

@ ismail-miguel memeras inisialisasi $leftdan $cdimasukkan ke dalam argumen echopenghematan 4 byte (lihat komentar di bawah).

Dengan menukar urutan variabel $mdan sdiinisialisasi saya menyingkirkan sepasang tanda kurung dan menyimpan 1 byte lebih.

JavaScript (ES6), 121 byte

Menggunakan string template, 2 baris baru di dalam string signifikan dan dihitung.

Untuk menyimpan byte, hasilkan dengan alert, bahkan jika font proporsional yang digunakan dalam alerttidak cocok untuk seni ASCII dan hasilnya jelek untuk n> = 20 (crash).

Tes menjalankan cuplikan di FireFox

F=n=>alert(`  __  
_/  \\_
o    o`.replace(/.+/g,v=>(Z=x=>' '.repeat(x)+v)(n<20?n:n=20)+Z(60-3*n)).replace('__/','/\\/'))

<input id=I value=10><button onclick='F(I.value)'>go</button>

Python 2, 148 byte

Ini menggunakan kode pelarian ANSI untuk menempatkan kursor di tempat yang tepat untuk menggambar mobil. Kemudian memeriksa untuk melihat apakah inputnya 20, jika itu, kembali dan menarik pada kap mobil.

Mengambil int dari stdin, output ke stdout.

p=lambda x:"u  __u_/  \_uo    o".replace("u","\n\033[%dC")%(x,x,x)+"\033[4A";i=min(20,input());print p(i)+"\n"+p(66-i*2)+"\n\n\n\033[25C/\\"*(i==20)

Tidak Disatukan:

def get_car(x):
    return "\n  __\n_/  \_\no    o".replace("\n","\n\033[%dC")%(x,x,x)+"\033[4A"

i=min(20,input())
print get_car(i)
print get_car(66-i*2)
if i==20:
    print"\n\n\033[25C/\\"

Pyth, 67 byte

Kjbm+++*\ JhS,Q20d*\ -60*3Jdc3"  __  _/  \_o    o"?nJ20KXXK58\/59\\

Cobalah di sini .

                                                                       Implicit: Q=eval(input())
          JhS,Q20                                                      Set J=min(Q,20)
                              "  __  _/  \_o    o"                     Concatenated car string
                            c3                                         Split into 3
   m                                                                   For d in the above
       *\ J                                                            J spaces before 1st car
                  *\ -60*3                                             60-3J spaces in between them
    +++          d         d                                           Concatenate spaces and car string
Kjb                                                                    Join on newlines, store in K
                                                  ?nJ20                If J != 20...
                                                       K               ... print K
                                                         XK58\/        ... else put / in position 58
                                                        X      59\\        and \ in position 59 (implicit print)

C, 180 191 168 byte

#define S(x,y)"  __  ",#x"/  \\"#y,"o    o",
char*s[][3]={S(_,_)S(_,/)S(\\,_)};i;l;f(n){l=n>19&&(n=20);for(i=0;i<3;i++)printf("%*s%*s\n",n+6,s[l][i],60-3*n,s[l*2][i]);}

ungolfed:

// make a map of possible car parts
#define S(x, y) { "  __  ", #x "/  \\" #y, "o    o" }
char * s[4][3]= {
    S(_,_),
    S(_,/),
    S(\\,_)
};
i,l;
f(n){
    i = 0;
    l = n>19 && (n = 20); // l = 1, if crash happend
    for(; i < 3; i++) {
        // '*' means length (padding) is given as an int argument
        printf("%*s%*s\n", n + 6, s[l][i], 60 - 3 * n, s[l*2][i]);
    }
}

program uji:

main() {
    f( 0);f( 5);f(10);
    f(15);f(20);f(21);
    return 0;
}

keluaran:

  __                                                          __
_/  \_                                                      _/  \_
o    o                                                      o    o
       __                                           __
     _/  \_                                       _/  \_
     o    o                                       o    o
            __                            __
          _/  \_                        _/  \_
          o    o                        o    o
                 __             __
               _/  \_         _/  \_
               o    o         o    o
                      __    __
                    _/  \/\/  \_
                    o    oo    o
                      __    __
                    _/  \/\/  \_
                    o    oo    o

Saya bisa bermain golf ini dengan cukup keras. Saya pikir saya mulai dengan hampir 300 byte.

Tapi saya tidak tahu apakah ini masih memenuhi semua persyaratan. Seperti yang dapat Anda lihat setelah 21 detik, mobil pertama mendorong mobil kedua ke kanan. Saya perlu menambahkan beberapa byte jika ini tidak diizinkan.

Edit: perbaiki. Ini harus lebih realistis daripada Sharknado ;-)

Sunting: Saya dapat secara signifikan mempersingkat solusi saya dengan melihat kedua halaman printfmanual. Jika Anda menggunakan '*' Anda dapat memberikan panjang bidang langsung ke printf, tanpa perlu membuat format-string sprintfsebelumnya.

> <> , 538 276 byte

 :3*a6*$-:0)?v~~a2*0c4*1-e2*1+6pa9*2+b7p04.
  v          >04.
 >>1[>:0)  ?v~].
  ^  ^-1o" "<
\$:&94&12." ":oo"_":oo" ":oo
\$:&95&12." ":oo"_":oo" ":ooao
\$:&96&12."_"o"/"o" ":oo"\"o"_"o
\$:&97&12."_"o"/"o" ":oo"\"o"_"oao
\$:&98&12."o"o" ":::oooo"o"o
\$:&99&12."o"o" ":::oooo"o"o;

Saya sudah menjatuhkan ukurannya BANYAK, saya kagum bahwa saya berhasil menurunkan ukurannya menjadi setengahnya. Yang lama ada di bawah. Yang satu ini tidak seefisien kinerja bijaksana karena lebar grid, kebanyakan dari baris pertama.

Anda dapat mengujinya di sini . Masukkan jumlah waktu yang berlalu di "Initial Stack", bukan "Input"!

Ini versi lama.

:3*a6*$-:0)  ?v~~a2*0c4*1-c3*1-4p^                        
v~v?)0:  <[1:$/$:1[ >:0)  ?v~]" ":oo"_":oo" ":ooaov       
] >" "o1-^    ^    <^-1o" "/"/"o"_"<]~v?)0:  <[1:$<       
>" ":oo"_":oo" ":oo^       \o" ":oo"\"\" "o1-^            
/o"\"oo:" "o"/"o"_"]~v?)0:  <[1:$o"_"o/                   
\"_"oaov   hi there  >" "o1-^                             
       >$:1[ >:0)  ?v~]"o"o" ":::oooo"o"o>$:1[ >:0)  ?v~]v
       ^    <^-1o" "<                    ^    <^-1o" "<   
              v      p4-1*29+2*9a<    ;o"o"oooo:::" "o"o"<

Jawa, 258 Karakter

class M{public static void main(String[]a){String l="",m=l,r="  __  ",w="o    o",x="_/  \\_";int p=Integer.parseInt(a[0]),i=20;p=p>i?i:p;for(i=-1;++i<p;)l+=" ";for(;++i<21;)m+="   ";System.out.print(l+r+m+r+"\n"+l+(x+m+x).replace("__","/\\")+"\n"+l+w+m+w);}}

Tidak Golf

  class M {
     public static void main(String[] a) {
        String l = "", m = l, r = "  __  ", w = "o    o", x = "_/  \\_";
        int p = Integer.parseInt(a[0]), i = 20;
        p = p > i ? i : p;
        for (i = -1; ++i < p;)
           l += " ";
        for (; ++i < 21;)
           m += "   ";
        System.out.print(l + r + m + r + "\n"
              + l + (x + m + x).replace("__", "/\\") + "\n"
              + l + w + m + w);
     }
  }

Hasil

0
  __                                                                __  
_/  \_                                                            _/  \_
o    o                                                            o    o

1
   __                                                             __  
 _/  \_                                                         _/  \_
 o    o                                                         o    o

...

19
                     __       __  
                   _/  \_   _/  \_
                   o    o   o    o

20
                      __    __  
                    _/  \/\/  \_
                    o    oo    o

21
                      __    __  
                    _/  \/\/  \_
                    o    oo    o      

Python 2, 102 byte

n=input()
for r in"  __  ","_/  \_","o    o":print((n*' ')[:20]+r+(60-3*n)*' '+r).replace('__/','/\/')

Cukup mudah. Untuk setiap baris mobil, kami mencetak nspasi, baris itu, 60-3*nspasi, dan baris lagi. Untuk menghentikan mobil, daripada melakukan min(n,20), itu adalah salah satu karakter yang lebih pendek untuk membatasi ruang pertama dengan[:20] , dan yang kedua baik-baik saja karena kali negatif string adalah string kosong.

Untuk naik fender, kami hanya melakukan a replace. Karena __juga muncul di atap, kita perlu sedikit konteks untuk mengidentifikasi fender, jadi kami memeriksa yang /berikut.

Jawa, 270 267 byte

Cukup yakin ada cara yang lebih baik / lebih pendek untuk melakukan ini, tetapi otak saya tidak terlibat dengan benar.

class C{public static void main(String[]a){String l="",m="",r="  __  ",w="o    o";int p=Math.min(Integer.parseInt(a[0]),20),i;for(i=0;++i<p;)l+=" ";for(i=0;++i<60-3*p;)m+=" ";System.out.print(l+r+m+r+"\n"+l+"_/  \\"+(p==20?"/"+m+"\\":"_"+m+"_")+"/  \\_\n"+l+w+m+w);}}

Untuk n = 19:

                    __      __  
                  _/  \_  _/  \_
                  o    o  o    o

Untuk n = 20:

                     __    __  
                   _/  \/\/  \_
                   o    oo    o

Tidak disatukan

public class Crash {
public static void main(String[] args) {
    String left="", mid="", r="  __  ", w="o    o";
    int pos = Math.min(Integer.parseInt(args[0]),20),i;
    for (i=0; ++i<pos;){
        left+=" ";
    }
    for (i=0; ++i<60-3*pos;){
        mid+=" ";
    }
    System.out.print(
            left + r + mid + r + "\n" +
            left + "_/  \\" + (pos==20 ? "/" + mid + "\\" : "_" + mid + "_") + "/  \\_\n" +
            left + w + mid + w);
}
}

PHP 7, 140 byte

<?$s=$argv[1];$r=($f=str_repeat)(~ß,60-3*$s);echo$l=$f(~ß,min(20,$s)),"  __  $r  __  
${l}_/  \\",$r?_.$r._:~У,"/  \_
$l",$o=~ßßßß,$r,$o;

Pemakaian:

Simpan sebagai ANSI di file.php(harus ada karakter dengan lebar nol $o) dan jalankan:

php -derror_reporting=~E_NOTICE -dshort_open_tag=1 file.php x

dengan xsebagai jumlah detik.

Dan versi yang berfungsi tanpa mengubah pelaporan kesalahan ( 148 byte ):

<?$s=$argv[1];$r=($f=@str_repeat)(' ',60-3*$s);echo$l=$f(' ',min(20,$s)),"  __  $r  __  
${l}_/  \\",$r?"_${r}_":"/\\","/  \_
$l",$o="o    o",$r,$o;

Javascript, 193 byte

Itu bukan pemenang, tapi itu sesuatu

http://jsfiddle.net/yb703y0p/2/

function f(n){
c = ["  __  A", "_/  \\_A", "o    oA"]
for(i=0;i<3;i++)c[i]=c[i].replace('A',' '.repeat(n))+c[i].replace('A','')
if(n==0)c[1]=c[1].replace('__','/\\')
console.log(c.join("\n"))
}