Wer liebt nicht Actionfilme mit schnellen, lauten Autos, besonders mit vielen Stürzen? Wer liebt Action-Shots in der ASCII-Kunst nicht?

Die Szene ist:

Zwei Autos starten an gegenüberliegenden Seiten einer geraden Straße (mit 60 Zwischenräumen). Sie fahren mit konstanter Geschwindigkeit aufeinander zu. Das linke Auto fährt mit 1 Leerzeichen pro Sekunde und das rechte mit 2 Leerzeichen pro Sekunde.

Offensichtlich können sich die Autos nicht gegenseitig passieren, so dass n ≥ 20die Szene aus zwei verunglückten Autos mit Motorhauben an der Stelle besteht, an der der Unfall aufgetreten ist.

Als Filmliebhaber möchte ich die Szene ab und zu pausieren, nur um die Schönheit zu genießen.

Bei einer gegebenen Ganzzahl n(Funktionsargument oder STDIN), die die Anzahl der Sekunden ab Beginn der Szene darstellt, wird die Szene zu diesem Zeitpunkt angezeigt.

Dies ist die Startszene mit 60 Zwischenräumen zwischen den Vorderrädern:

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

das ist die szene nach 11 sekunden:

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

und so sieht es nach dem Crash aus (beachte, dass die Motorhauben nach dem Crash oben sind):

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

Ich bin nur daran interessiert zu sehen, wie zwei Autos zusammenstoßen, Leerzeichen, Zeilenumbrüche, ++ spielen keine Rolle.

Dies ist Codegolf, also gewinnt der kürzeste Code in Bytes. Später hinzugefügte Antworten können immer noch gewinnen, wenn sie kürzer als die aktuell akzeptierte Antwort sind.

CJam, 68 66 Bytes

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

Probieren Sie es online aus

Jeder, der den Anfang des Codes sieht, ist sich dessen sicher liKe!

Erläuterung:

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

Ich stelle stolz vor ...

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

... mein neues zweidimensionales Esolang-Labyrinth! Der obige Code ist nicht besonders gut umgesetzt (es gibt 161 Felder und 25 NOPs, so dass ein besseres Layout dies erheblich verkürzen könnte), aber ich konnte zumindest zeigen, dass die Sprache für nicht-triviale Aufgaben geeignet ist. :)

Wie es funktioniert

Zunächst ein kurzer Überblick über die Sprache:

• Labyrinth arbeitet mit zwei Stapeln, Haupt- und Hilfsstapel , in denen beliebige Ganzzahlen mit Vorzeichen gespeichert werden können. Am Ende beider Stapel befindet sich eine unendliche Anzahl von Nullen.
• Befehle sind einzelne Zeichen in einem 2D-Raster und bilden ein Labyrinth (dh unbekannte Zeichen, insbesondere Leerzeichen, sind Wände). "ist ein NOP, der keine Pinnwand ist und zum Auffüllen bestimmter Pfade im Code hilfreich sein kann. Im Gegensatz zu vielen anderen 2D-Sprachen werden die Kanten nicht umbrochen.
• Der Anweisungszeiger (IP) beginnt beim ersten Zeichen ohne Wand (in Lesereihenfolge), das sich nach rechts bewegt. @Beendet das Programm.
• Wenn möglich, folgt die IP Korridoren (auch um Kurven). Wenn die IP mehrere Zellen hat, auf die verschoben werden soll, wird sie im Allgemeinen nach links gedreht, wenn der obere Rand des Hauptstapels negativ ist, geradeaus, wenn er null ist, oder nach rechts, wenn er positiv ist. Wenn die IP gegen eine Wand stößt, kehrt sie die Richtung um. (Es gibt noch ein paar Feinheiten, aber diese sollten für diesen Code keine Rolle spielen.) Dies ist die einzige Möglichkeit, den Steuerungsfluss zu implementieren.
• Abgesehen von Rechen- und Stapelmanipulationsbefehlen kann der Quellcode zur Laufzeit mit den vier Befehlen geändert >v<^werden, die eine Zeile oder Spalte des Quellcodes zyklisch um eine Zelle verschieben. Welche Zeile oder Spalte betroffen ist, hängt von der Stapelspitze ab. Wenn die eigene Zeile oder Spalte der IP verschoben wird, bewegt sie sich mit der Verschiebung. Dies ermöglicht es, von einer Kante des Quellcodes zur anderen zu springen.

Für diese besondere Herausforderung ist hier die allgemeine Idee des Algorithmus:

• Schieben Sie die Enden der Autos bis zu den Motorhauben (dh / \_o oo o) auf den Zusatzstapel.
• Lesen Sie die Eingabe und bestimmen Sie, ob Sie drücken __oder als /\nächstes.
• Schieben Sie den Rest der Autos (dh __ __ _/ \und zwei führende Leerzeichen) auf den Zusatzstapel.
• Klemmen Sie den Eingang auf einen Maximalwert von 20, nennen wir diese N .
• Jetzt mache 3 mal folgendes:
  • Drucken N Plätze.
  • Drucken Sie 6 gespeicherte Zeichen.
  • Drucken Sie 60 - 3 * N Leerzeichen.
  • Drucken Sie 6 gespeicherte Zeichen.
  • Drucken Sie eine neue Zeile.

Schauen wir uns zum Schluss einige Teile des Codes an. Die IP beginnt in der oberen linken Ecke mit einem Befehl zum Verschieben des Rasters. Der obere Teil des Hauptstapels ist 0(der als relativer Index verwendet wird), daher wird die erste Zeile nach links verschoben, wodurch auch die IP an das rechte Ende des Rasters verschoben wird. Jetzt wird die erste Zeile einfach von rechts nach links ausgeführt, wodurch der erste Satz fester Zeichen auf den Zusatzstapel verschoben wird:

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

Diese Zeilenverschiebung ist nützlich zum Golfen, wenn Sie mit einer großen Menge linearen Codes beginnen möchten.

Als nächstes lesen wir die Eingabe und schieben die richtigen Hauben:

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

Das linke Bit mit den drei NOPs sendet negative Ergebnisse entlang des oberen Zweigs und nicht negative Ergebnisse entlang des unteren Zweigs. Rechts werden sie wieder zusammengefügt.

Nun folgt ein weiterer großer linearer Abschnitt (der wahrscheinlich mit einem anderen Trick zum Verschieben von Reihen viel Golf gespielt werden könnte):

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

Dies drückt den Rest der Autos auf den Hilfsstapel.

Als nächstes berechnen wir min(20, input), was dem ersten Zweig ähnlich ist:

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

Schließlich haben wir die Schleife, die dreimal ausgeführt wird, um die Zeilen zu drucken. Jede Iteration der Schleife enthält zwei kleine (3x3) Schleifen zum Drucken der Leerzeichen sowie zwei Abschnitte zum Drucken von 6 Zeichen aus dem Zusatzstapel:

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

Ein guter Trick, auf den ich gerne aufmerksam machen möchte, ist der .{.{.am rechten Rand. Dies ist eine Sackgasse. Abgesehen von der Sackgasse wird .der Code zweimal ausgeführt, einmal vorwärts und einmal rückwärts. Dies bietet eine gute Möglichkeit, den Palindrom-Code zu verkürzen (der Haken ist, dass Sie sicherstellen müssen, dass die IP die richtige Kurve nimmt, wenn Sie die Sackgasse wieder verlassen).

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

Dies nimmt Eingaben von stdin entgegen.
Demo hier
Testen Sie diese -

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

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

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

R, 191 Bytes

Etwa so gut wie ich es jetzt bekommen kann. Nimmt die Sekunden von STDIN und Katzen zu 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')

Erläuterung

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

Tests

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

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

Demo

Ungolfed:

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 bis 155 Bytes

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

Der Code wird hier in 3 Zeilen angezeigt, um dem Layout des Codefelds zu entsprechen. Diese Zeilenumbrüche werden nicht benötigt.

Der ungolfed Code:

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

Es wird die Anzahl der Sekunden von der Befehlszeile abgerufen (erstes Argument):

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

Die PHP-CLI-Option -d error_reporting=0wird benötigt, um einige Hinweise auszublenden, die PHP zu undefinierten Konstanten ( str_repeat, _) anzeigt , die es in Zeichenfolgen konvertiert (2 Byte, die für jeden Hinweis gespeichert werden).

Ein zusätzliches Byte kann in PHP 7 gespeichert werden, indem die Initialisierung von $fbei der ersten Verwendung gedrückt wird ( $m=($f=str_repeat)(...)). Es kann nicht mit PHP 5 kompiliert werden.

Der Testfall und einige der zum Verkleinern des Codes verwendeten Techniken sind auf github zu finden .

Aktualisieren:

@ ismail-miguel hat die Initialisierung von $leftund $cdie Argumente für die echoEinsparung von 4 Bytes unterstrichen (siehe Kommentar unten).

Durch Vertauschen der Reihenfolge der Variablen $mund der sInitialisierung habe ich ein Paar Klammern entfernt und 1 Byte mehr gespart.

JavaScript (ES6), 121 Byte

Unter Verwendung der Schablonenzeichenfolge sind die 2 Zeilenumbrüche in der Zeichenfolge von Bedeutung und werden gezählt.

Um Bytes zu sparen, geben Sie mit aus alert, auch wenn die in verwendete proportionale Schriftart alertfür ASCII-Grafiken nicht gut geeignet ist und das Ergebnis für n> = 20 (Absturz) hässlich ist.

Testen Sie das Ausführen des Snippets in 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 Bytes

Dies verwendet ANSI-Escape-Codes, um den Cursor an der richtigen Stelle zu positionieren, um die Autos zu zeichnen. Anschließend wird geprüft, ob die Eingabe 20 war. Wenn dies der Fall ist, wird zurückgegangen und auf die Motorhauben des Autos zurückgegriffen.

Übernimmt ein Int von stdin und gibt es an stdout aus.

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)

Ungolfed:

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 Bytes

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

Probieren Sie es hier aus .

                                                                       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 Bytes

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

Testprogramm:

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

Ausgabe:

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

Ich konnte dieses Spiel ziemlich hart spielen. Ich glaube ich habe mit fast 300 Bytes angefangen.

Aber ich weiß nicht, ob dies noch alle Anforderungen erfüllt. Wie Sie nach 21 Sekunden sehen können, schiebt das erste Auto das zweite Auto nach rechts. Ich müsste ein paar Bytes hinzufügen, wenn dies nicht erlaubt ist.

Bearbeiten: behoben. Das sollte realistischer sein als Sharknado ;-)

Bearbeiten: Ich könnte meine Lösung erheblich verkürzen, indem ich mir die printfManpage noch einmal anschaue . Wenn Sie '*' verwenden, können Sie die Feldlänge direkt an printf übergeben, ohne sprintfvorher einen Format-String mit erstellen zu müssen.

> <> , 538 276 Bytes

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

Ich habe die Größe VIEL reduziert, ich bin erstaunt, dass ich es geschafft habe, die Größe um die Hälfte zu reduzieren. Der alte ist unten. Dieser ist aufgrund der Breite des Gitters, meistens von der ersten Zeile an, nicht so leistungsfähig.

Sie können es hier ausprobieren . Legen Sie die verstrichene Zeit in den "Initial Stack" und nicht in "Input"!

Hier ist die alte Version.

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

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

Ungolfen

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

Ergebnisse

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 Bytes

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

Ziemlich einfach. Für jede Reihe des Autos drucken wir nLeerzeichen, diese Reihe, 60-3*nLeerzeichen und die Reihe erneut. Um die Autos anzuhalten, anstatt dies zu tun min(n,20), war es ein Zeichen kürzer, den ersten Durchgang von Leerzeichen mit zu begrenzen [:20], und das zweite ist in Ordnung, da ein negativer Zeitpunkt, zu dem eine Zeichenfolge die leere Zeichenfolge ist.

Um die Kotflügel nach oben zu bewegen, machen wir einfach a replace. Da __auch auf dem Dach erscheint, brauchen wir ein bisschen Kontext, um die Kotflügel zu identifizieren, also suchen wir nach /Folgendem.

Java, 270 - 267 Byte

Ich bin mir ziemlich sicher, dass es einen besseren / kürzeren Weg gibt, aber mein Gehirn ist nicht richtig beschäftigt.

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

Für n = 19:

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

Für n = 20:

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

Ungolfed

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 Bytes

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

Verwendung:

Speichern Sie als ANSI in file.php(es sollten Zeichen mit der Breite Null in sein $o) und führen Sie Folgendes aus:

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

mit xwie die Anzahl der Sekunden.

Und eine Version, die ohne Änderung der Fehlerberichterstattung ( 148 Byte ) funktioniert :

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

Es ist kein Gewinner, aber es ist etwas

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