Kto nie lubi filmów akcji z szybkimi hałaśliwymi samochodami, zwłaszcza z wieloma awariami? Kto nie lubi zdjęć akcji w sztuce ascii?

Scena jest:

Dwa samochody ruszają po przeciwnych stronach prostej drogi (między nimi 60 miejsc). Zaczynają jechać ku sobie ze stałą prędkością. Samochód po lewej jedzie z prędkością 1 miejsca na sekundę, a ten z prawej jedzie z prędkością 2 miejsc na sekundę.

Oczywiście samochody nie mogą się przejechać, więc n ≥ 20sceną będą dwa rozbite samochody z czepkami w miejscu, w którym doszło do wypadku.

Jako miłośnik kina chcę od czasu do czasu zatrzymać scenę, aby cieszyć się jej pięknem.

Biorąc pod uwagę liczbę całkowitą n(argument funkcji lub STDIN), reprezentującą liczbę sekund od początku sceny, pokaż scenę w tym momencie.

Oto scena początkowa z 60 odstępami między przednimi kołami:

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

to jest scena po 11 sekundach:

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

i tak to wygląda po awarii (pamiętaj, że po awarii maski są podniesione):

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

Interesuje mnie tylko awaria dwóch samochodów, więc spacje, znaki nowej linii, ++ nie mają znaczenia.

To jest kod golfowy, więc wygrywa najkrótszy kod w bajtach. Odpowiedzi dodane później mogą nadal wygrywać, jeśli są krótsze niż aktualnie zaakceptowana odpowiedź.

CJam, 68 66 bajtów

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

Wypróbuj online

Każdy, kto zobaczy początek kodu, będzie tego pewien liKe!

Wyjaśnienie:

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.

Labirynt , 394 386 bajtów

Z dumą przedstawiam ...

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

... mój nowy dwuwymiarowy esolang Labirynt! Powyższy kod nie jest niewiarygodnie dobrze golfowy (jest 161 pól i 25 NOP, więc lepszy układ może to znacznie skrócić), ale przynajmniej udało mi się pokazać, że język nadaje się do zadań niebanalnych. :)

Jak to działa

Najpierw krótki przegląd języka:

• Labirynt działa na dwóch stosach, głównym i pomocniczym , które mogą zawierać dowolne liczby całkowite ze znakiem. Na dole obu stosów znajduje się nieskończona ilość zer.
• Polecenia to pojedyncze znaki na siatce 2D i tworzą labirynt (to znaczy nieznane postacie, zwłaszcza spacje, są ścianami). "jest NOP, który nie jest ścianą i może być pomocny przy wypełnianiu określonych ścieżek w kodzie. W przeciwieństwie do wielu innych języków 2D krawędzie nie zawijają się.
• Wskaźnik instrukcji (IP) zaczyna się od pierwszego nie-ściennego znaku (w kolejności czytania) przesuwającego się w prawo. @kończy program.
• Jeśli to możliwe, IP przebiega wzdłuż korytarzy (również wokół zakrętów). Jeśli adres IP ma do przejścia wiele komórek, zazwyczaj skręca w lewo, jeśli góra głównego stosu jest ujemna, poruszaj się na wprost, jeśli wynosi zero, lub skręć w prawo, jeśli jest dodatnia. Kiedy IP uderza w ścianę, odwraca kierunek. (Jest jeszcze kilka subtelności, ale nie powinny one mieć znaczenia dla tego kodu.) Jest to jedyny sposób na wdrożenie przepływu sterowania.
• Oprócz poleceń arytmetycznych i manipulacji na stosie, kod źródłowy można modyfikować w czasie wykonywania za pomocą czterech poleceń, >v<^które cyklicznie przesuwają wiersz lub kolumnę kodu źródłowego o jedną komórkę. To, którego wiersza lub kolumny dotyczy, zależy od góry stosu. Jeśli własny wiersz lub kolumna adresu IP zostanie przesunięta, będzie się przesuwać wraz z przesunięciem. Umożliwia to przeskakiwanie z jednej krawędzi kodu źródłowego na drugą.

Teraz, w przypadku tego konkretnego wyzwania, oto ogólna idea algorytmu:

• Dociśnij końce samochodów do czapek (tj. / \_o oo o) Na stos pomocniczy.
• Przeczytaj dane wejściowe i określ, czy naciskać, __czy /\dalej.
• Wciśnij resztę samochodów (tj. __ __ _/ \Dwie spacje wiodące) na stos pomocniczy.
• Zablokuj wejście do maksymalnej wartości 20, nazwijmy to N .
• Teraz wykonaj następujące 3 razy:
  • Wydrukuj N spacji.
  • Wydrukuj 6 zapisanych znaków.
  • Wydrukuj 60-3 * N spacji.
  • Wydrukuj 6 zapisanych znaków.
  • Wydrukuj nowy wiersz.

Na koniec spójrzmy na niektóre części kodu. Adres IP zaczyna się w lewym górnym rogu, za pomocą polecenia przesunięcia siatki. Góra głównego stosu jest 0(która jest używana jako indeks względny), więc pierwszy rząd jest przesunięty w lewo, co również przesuwa IP na prawy koniec siatki. Teraz pierwszy rząd jest po prostu wykonywany od prawej do lewej, co wypycha pierwszy zestaw stałych znaków na stos pomocniczy:

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

To przesunięcie wiersza jest przydatne podczas gry w golfa, gdy chcesz zacząć od dużej ilości kodu liniowego.

Następnie czytamy dane wejściowe i wciskamy odpowiednie maski:

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

Bit po lewej z trzema NOP wysyła negatywne wyniki wzdłuż górnej gałęzi i nieujemne wyniki wzdłuż dolnej gałęzi. Po prawej są ponownie połączone.

Teraz następuje kolejna duża sekcja liniowa (która prawdopodobnie mogłaby być często golfa z inną sztuczką polegającą na przesuwaniu rzędów):

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

Spycha to resztę samochodów na stos pomocniczy.

Następnie obliczamy min(20, input), która jest podobna do pierwszej gałęzi:

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

Wreszcie mamy pętlę, która działa trzy razy, aby wydrukować linie. Każda iteracja pętli zawiera dwie małe (3x3) pętle do drukowania spacji, a także dwie sekcje do drukowania 6 znaków ze stosu pomocniczego:

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

Jedną fajną sztuczką, na którą chciałbym zwrócić uwagę, jest .{.{.jej prawy brzeg. Jest to ślepy zaułek, więc poza .końcem kod jest wykonywany dwukrotnie, raz do przodu i raz do tyłu. Daje to dobry sposób na skrócenie kodu palindromicznego (haczyk polega na tym, że musisz upewnić się, że IP przybiera prawidłowy obrót przy ponownym wyjściu z ślepej uliczki).

Python 2.7, 167 164 159 bajtów

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("//","\/")

To pobiera dane wejściowe ze standardowego wejścia.
Demo tutaj
Testowanie tego -

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

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

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

R, 191 bajtów

O tyle, ile mogę teraz. Zajmuje sekundy od STDIN i kotów do 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')

Wyjaśnienie

# 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')

Testy

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

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

Próbny

Nie golfowany:

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

Próbny

PHP, 160 155 bajtów

$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";

Kod jest wyświetlany tutaj w 3 wierszach, aby pasował do układu pola kodu. Te nowe wiersze nie są potrzebne.

Nieskluczony kod:

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

Pobiera liczbę sekund z wiersza poleceń (pierwszy argument):

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

Opcja PHP CLI -d error_reporting=0jest potrzebna do ukrycia niektórych powiadomień wyświetlanych przez PHP o niezdefiniowanych stałych ( str_repeat,_ ), które konwertuje na ciągi znaków (2 bajty zapisane dla każdego powiadomienia).

Jeden dodatkowy bajt można zapisać w PHP 7, ściskając inicjalizację $fdo pierwszego użycia ($m=($f=str_repeat)(...) ); nie kompiluje się w PHP 5.

Przypadek testowy i niektóre techniki stosowane w celu zmniejszenia kodu można znaleźć na github .

Aktualizacja:

@ ismail-miguel ścisnął inicjalizację $lefti $cwprowadził do argumentówecho zapisywania 4 bajtów (patrz komentarz poniżej).

Poprzez zamianę kolejności zmiennych $mi sich inicjalizację pozbyłem się pary nawiasów i zaoszczędziłem jeszcze 1 bajt.

JavaScript (ES6), 121 bajtów

Używając ciągu szablonu, 2 znaki nowego wiersza w ciągu są znaczące i zliczane.

Aby zapisać bajty, wypisz za pomocą alert, nawet jeśli użyto proporcjonalnej czcionkialert nie jest odpowiednia dla grafiki ASCII, a wynik jest brzydki dla n> = 20 (awaria).

Przetestuj uruchomienie fragmentu kodu w 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 bajtów

Wykorzystuje kody ucieczki ANSI, aby ustawić kursor we właściwym miejscu, aby narysować samochody. Następnie sprawdza, czy dane wejściowe wynosiły 20, a jeśli tak, to wraca i rysuje maski samochodu.

Pobiera liczbę całkowitą ze standardowego wyjścia na wyjście standardowe.

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)

Nie golfowany:

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

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

Wypróbuj tutaj .

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

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

bez golfa:

// 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 testowy:

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

wydajność:

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

Byłem w stanie grać w golfa dość mocno. Myślę, że zacząłem z prawie 300 bajtami.

Ale nie wiem, czy to nadal spełnia wszystkie wymagania. Jak widać po 21 sekundach, pierwszy samochód popycha drugi samochód w prawo. Musiałbym dodać kilka bajtów, jeśli nie jest to dozwolone.

Edycja: naprawiono. To powinno być bardziej realistyczne niż Sharknado ;-)

Edycja: Mogłem znacznie skrócić moje rozwiązanie, patrząc ponownie na stronę podręcznika użytkownika printf. Jeśli użyjesz „*”, możesz podać długość pola bezpośrednio do printf, bez potrzeby wcześniejszego tworzenia łańcucha formatującego sprintf.

> <> , 538 276 bajtów

 :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;

Zrzuciłem rozmiar DUŻO, jestem zdumiony, że udało mi się zmniejszyć rozmiar o połowę. Stary jest poniżej. Ten nie jest tak wydajny pod względem wydajności ze względu na szerokość siatki, głównie od pierwszej linii.

Możesz to przetestować tutaj . Podaj czas, który upłynął, w „Początkowym stosie”, a nie „Wejściu”!

Oto stara wersja.

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

Java, 258 znaków

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

Bez golfa

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

Wyniki

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 bajty

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

Całkiem proste. Dla każdego rzędu samochodu drukujemy nspacje, ten rząd, 60-3*nspacje i rząd ponownie. Aby zatrzymać samochody, zamiast o min(n,20)jeden, ograniczać pierwszy ciąg przestrzeni za pomocą jednego znaku[:20] ciąg , a drugi jest w porządku, ponieważ liczba ujemna razy ciąg jest pustym ciągiem.

Aby przesunąć błotniki, po prostu wykonujemy replace. Ponieważ __pojawia się również na dachu, potrzebujemy trochę kontekstu, aby zidentyfikować błotniki, więc sprawdzamy, czy są /następujące.

Java, 270 267 bajtów

Jestem całkiem pewien, że istnieje lepszy / krótszy sposób, ale mój mózg nie jest odpowiednio zaangażowany.

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

Dla n = 19:

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

Dla n = 20:

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

Bez golfa

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

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

Stosowanie:

Zapisz jako ANSI w file.php(powinny być w niej znaki o zerowej szerokości $o) i uruchom:

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

z x jako liczba sekund.

I wersja, która działa bez zmiany raportowania błędów ( 148 bajtów ):

<?$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 bajty

To nie jest zwycięzca, ale coś

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