谁不喜欢快速嘈杂的汽车动作电影，尤其是那些发生大量车祸的电影？谁不喜欢ASCII艺术动作镜头？

场景是：

两辆汽车从一条直线道路的相对两侧开始（之间有60个间隔）。他们开始以恒定的速度向彼此行驶。左边的汽车以每秒1个车位的速度行驶，右边的汽车以每秒2个车位的速度行驶。

显然，汽车无法相互通过，因此对于n ≥ 20场景，将是两辆坠毁的汽车，它们在发生碰撞的位置举起了引擎盖。

作为电影爱好者，我想时不时地暂停场景，只是为了欣赏它的美丽。

给定一个整数n（函数自变量或STDIN），表示从场景开始算起的秒数，请显示该时刻的场景。

这是开始的场景，前轮之间有60个空格：

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

这是11秒后的场景：

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

这就是崩溃后的样子（请注意，崩溃后引擎盖已打开）：

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

我只想看两辆车相撞，所以空格，换行符，++都没关系。

这是代码高尔夫，因此以字节为单位的最短代码获胜。如果后来添加的答案比当前接受的答案短，则仍然可以获胜。

CJam，68 66字节

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

在线尝试

任何看到代码开始的人都可以肯定的liKe！

说明：

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.

迷宫，394386字节

我自豪地介绍...

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

...我的新二维esolang迷宫！上面的代码使用起来并不十分理想（有161个空格和25个NOP，所以更好的布局可以缩短很多时间），但是至少我设法证明了该语言可用于非平凡的任务。:)

怎么运行的

首先，快速概述一下该语言：

• 迷宫在两个堆栈上运行：main和辅助，可以容纳任意有符号整数。在两个堆栈的底部，都有无限数量的零。
• 命令是2D网格上的单个字符，它们形成一个迷宫（这是未知字符，尤其是空格，是墙）。"是一个NOP，它不是一堵墙，可以帮助填充代码中的某些路径。与许多其他2D语言相反，这些边缘不会环绕。
• 指令指针（IP）从向右移动的第一个非墙壁字符（按读取顺序）开始。@终止程序。
• 如果可能，IP沿着走廊（也包括弯道）走。如果IP有多个要移动的单元，如果主堆栈的顶部为负，则通常会向左移动；如果为零，则通常会向前直接移动；如果为正，则通常会向右移动。当IP碰到墙时，它会反转方向。（还有一些细微之处，但是对于此代码而言，它们无关紧要。）这是实现控制流的唯一方法。
• 除了算术和堆栈操作命令之外，还可以在运行时使用这四个命令来修改源代码，这四个命令>v<^会将源代码的行或列循环移位一个单元格。受影响的行或列取决于堆栈的顶部。如果IP自身的行或列发生偏移，则它将随偏移而移动。这样就可以从源代码的一侧跳到另一侧。

现在，对于这个特殊的挑战，这是算法的一般概念：

• 将汽车的末端向上推至引擎盖上的引擎盖（即/ \_o oo o）。
• 读取输入，并确定是按下__还是/\下一步。
• 将其余轿厢（即__ __ _/ \两个前导空间）推入辅助烟囱。
• 用镊子输入到的最大值20，我们称之为ñ。
• 现在执行以下3次：
  • 打印N个空格。
  • 打印6个存储的字符。
  • 打印60-3 * N个空格。
  • 打印6个存储的字符。
  • 打印换行符。

最后，让我们看一下代码的某些部分。IP在网格移动命令中从左上角开始。主堆栈的顶部是0（用作相对索引），因此第一行移到左侧，这也将IP移到网格的右端。现在，只需从右到左执行第一行，这会将第一组固定字符压入辅助堆栈：

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

当您要从大量线性代码开始时，此行移位对于打高尔夫球很有用。

接下来，我们阅读输入并按下正确的阀盖：

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

三个NOP的左侧位沿顶部分支发送负结果，沿底部分支发送非负结果。在右侧，它们重新结合在一起。

现在跟随另一个大的线性部分（可能使用另一种行移位技巧来进行很多操作）：

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

这会将其余的轿厢推到辅助烟囱上。

接下来，我们计算min(20, input)，类似于第一个分支：

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

最后，我们有了循环，该循环运行了3次以打印行。循环的每次迭代都包含两个小的（3x3）循环来打印空格，以及两个部分来打印辅助堆栈中的6个字符：

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

我想引起注意的一个妙招是.{.{.在右边。这是一个死胡同，因此除了.结束时，代码还执行两次，一次执行一次，一次执行一次。这提供了一种缩短回文码的巧妙方法（要注意的是，当再次退出死胡同时，您需要确保IP走正确的转向）。

Python 2.7， 167 164 159字节

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

这需要从stdin输入。
演示在这里
测试-

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

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

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

R，191字节

大概我现在能得到。从STDIN和猫到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')

说明

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

测验

> 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字节

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

演示版

取消高尔夫：

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

演示版

PHP，160个 155字节

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

代码在此处以3行显示，以适合代码框的布局。不需要那些换行符。

取消编码：

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

它从命令行（第一个参数）获取秒数：

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

-d error_reporting=0需要PHP CLI选项来隐藏一些通知，PHP会显示未定义的常量（str_repeat，_），它将转换为字符串（每个通知保存2个字节）。

通过将初始化压缩$f为第一次使用（$m=($f=str_repeat)(...)），可以在PHP 7上节省一个额外的字节。它不能在PHP 5上编译。

可以在github上找到测试用例和一些用于收缩代码的技术。

更新：

@ ismail-miguel压缩了初始化$left并内联$c到echo保存4个字节的参数中（请参阅下面的注释）。

通过交换变量的顺序$m并s进行初始化，我去除了一对括号并节省了1个字节。

JavaScript（ES6），121个字节

使用模板字符串，字符串中的2个换行符是有效的并计数。

为了节省字节，alert即使使用的比例字体alert不太适合ASCII艺术，并且对于n> = 20（崩溃）也很丑陋，请使用进行输出。

在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字节

这使用ANSI转义码将光标定位在正确的位置以绘制汽车。然后，它检查输入是否为20，如果输入为20，则返回并使用汽车的引擎盖。

从stdin获取一个int，输出到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)

取消高尔夫：

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个字节

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

在这里尝试一下。

                                                                       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字节

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

松散：

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

测试程序：

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

输出：

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

我能够非常努力地打高尔夫球。我想我从近300个字节开始。

但是我不知道这是否还能满足所有要求。正如您在21秒后看到的那样，第一辆车将第二辆车推到右侧。如果不允许这样做，我将需要添加一些字节。

编辑：修复它。这应该比Sharknado更现实；-)

编辑：通过再次查看printf手册页，我可以大大缩短解决方案。如果使用“ *”，则可以将字段长度直接提供给printf，而无需sprintf事先创建格式字符串。

> <>，538276字节

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

我把很多尺码都丢了，我很惊讶我把尺码减了一半。旧的在下面。由于网格的宽度（主要是从第一行开始），因此这不是高效的性能。

您可以在这里进行测试。将经过的时间放在“初始堆栈”中，而不是在“输入”中！

这是旧版本。

: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个字符

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

未打高尔夫球

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

结果

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字节

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

非常简单。对于汽车的每一行，我们再次打印n空格，该行，60-3*n空格和该行。要停止汽车，而不是停止汽车，min(n,20)用来限制第一次走行要短一个字符[:20]，第二次就可以了，因为负数是空字符串。

要使挡泥板向上移动，我们只需做一个即可replace。由于__也出现在屋顶上，因此我们需要一些上下文来识别挡泥板，因此我们检查是否有挡泥板/。

Java 270个 267字节

可以肯定的是，这样做的方法更好/更短，但是我的大脑没有适当地参与其中。

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

对于n = 19：

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

对于n = 20：

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

不打高尔夫球

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字节

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

用法：

另存为ANSI file.php（在其中应使用零宽度字符$o）并运行：

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

与 x秒为单位。

并在不更改错误报告的情况下工作的版本（148个字节）：

<?$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个字节

它不是赢家，但却是

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