Ai lại không thích những bộ phim hành động với những chiếc xe ồn ào, đặc biệt là những bộ phim có nhiều vụ tai nạn? Ai không thích những pha hành động trong nghệ thuật ascii?

Hiện trường là:

Hai chiếc xe đang bắt đầu ở hai bên đối diện của một con đường thẳng (với 60 khoảng cách giữa). Họ bắt đầu lái xe về phía nhau với tốc độ không đổi. Chiếc xe bên trái lái xe với tốc độ 1 không gian mỗi giây, và chiếc bên phải ổ đĩa ở tốc độ 2 không gian mỗi giây.

Rõ ràng, những chiếc xe không thể đi qua nhau, vì vậy n ≥ 20, hiện trường sẽ là hai chiếc xe bị đâm với nắp ca-pô tại vị trí xảy ra vụ tai nạn.

Là một người yêu thích phim, tôi muốn tạm dừng cảnh này ngay bây giờ, chỉ để tận hưởng vẻ đẹp của nó.

Cho một số nguyên n(đối số hàm hoặc STDIN), biểu thị số giây từ khi bắt đầu cảnh, hiển thị cảnh tại thời điểm đó.

Đây là cảnh bắt đầu, với 60 khoảng trống giữa các bánh trước:

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

đây là cảnh sau 11 giây:

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

và đây là những gì nó trông giống như sau vụ tai nạn (lưu ý rằng các nắp ca-pô đã lên sau vụ tai nạn):

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

Tôi chỉ quan tâm đến việc xem hai chiếc xe bị đâm, vì vậy không gian, dòng mới, ++ không thành vấn đề.

Đây là mã golf, vì vậy mã ngắn nhất tính bằng byte sẽ thắng. Câu trả lời được thêm vào sau vẫn có thể giành chiến thắng nếu chúng ngắn hơn câu trả lời được chấp nhận hiện tại.

CJam, 68 66 byte

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

Dùng thử trực tuyến

Bất cứ ai nhìn thấy sự bắt đầu của mã sẽ chắc chắn với liKenó!

Giải trình:

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.

Mê cung , 394 386 byte

Tôi tự hào giới thiệu ...

<}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ê cung esolang hai chiều mới của tôi! Đoạn mã trên không được chơi tốt đến mức khó tin (có 161 khoảng trắng và 25 NOP, vì vậy bố cục tốt hơn có thể rút ngắn điều này rất nhiều), nhưng ít nhất tôi đã xoay sở để chứng minh rằng ngôn ngữ có thể sử dụng được cho các nhiệm vụ không tầm thường. :)

Làm thế nào nó hoạt động

Đầu tiên, tổng quan nhanh về ngôn ngữ:

• Labyrinth hoạt động trên hai ngăn xếp, chính và phụ , có thể chứa các số nguyên được ký tùy ý. Ở dưới cùng của cả hai ngăn xếp có một số lượng vô hạn.
• Các lệnh là các ký tự riêng lẻ trên lưới 2D và chúng tạo thành một mê cung (đó là các ký tự không xác định, đặc biệt là các khoảng trắng, là các bức tường). "là một NOP không phải là một bức tường và có thể hữu ích cho việc đệm các đường dẫn nhất định trong mã. Trái ngược với nhiều ngôn ngữ 2D khác, các cạnh không bao quanh.
• Con trỏ lệnh (IP) bắt đầu ở ký tự không tường đầu tiên (theo thứ tự đọc) di chuyển sang phải. @chấm dứt chương trình.
• Nếu có thể, IP sẽ theo các hành lang (cũng quanh các khúc cua). Nếu IP có nhiều ô để di chuyển, nó thường sẽ rẽ trái nếu đỉnh của ngăn chính là âm, di chuyển thẳng về phía trước nếu nó bằng 0 hoặc rẽ phải nếu nó dương. Khi IP chạm vào tường, nó sẽ đảo ngược hướng. (Có thêm một vài sự tinh tế, nhưng chúng không quan trọng đối với mã này.) Đây là cách duy nhất để thực hiện luồng điều khiển.
• Ngoài các lệnh thao tác số học và ngăn xếp, mã nguồn có thể được sửa đổi trong thời gian chạy với bốn lệnh >v<^sẽ dịch chuyển một hàng hoặc cột của mã nguồn theo chu kỳ bởi một ô. Hàng hoặc cột nào bị ảnh hưởng phụ thuộc vào đỉnh của ngăn xếp. Nếu hàng hoặc cột riêng của IP bị dịch chuyển, nó sẽ di chuyển theo ca. Điều này làm cho nó có thể nhảy từ một cạnh của mã nguồn sang bên kia.

Bây giờ cho thử thách đặc biệt này, đây là ý tưởng chung của thuật toán:

• Đẩy các đầu của xe lên tới các nắp ca-pô (tức là / \_o oo o ) vào ngăn phụ.
• Đọc đầu vào và xác định xem có nên đẩy __hay không/\ tiếp theo.
• Đẩy phần còn lại của những chiếc xe (tức là __ __ _/ \ và hai khoảng trống dẫn đầu) lên ngăn phụ.
• Kẹp đầu vào với giá trị tối đa là 20, hãy gọi N này .
• Bây giờ làm 3 lần sau:
  • In N khoảng trắng.
  • In 6 ký tự được lưu trữ.
  • In khoảng trắng 60 - 3 * N.
  • In 6 ký tự được lưu trữ.
  • In một dòng mới.

Cuối cùng, hãy xem xét một số phần của mã. IP bắt đầu ở góc trên cùng bên trái, trên lệnh dịch chuyển lưới. Đỉnh của ngăn xếp chính là 0(được sử dụng như một chỉ số tương đối), vì vậy hàng đầu tiên được dịch sang trái, nó cũng di chuyển IP sang đầu bên phải của lưới. Bây giờ hàng đầu tiên được thực hiện đơn giản từ phải sang trái, sẽ đẩy tập hợp các ký tự cố định đầu tiên lên ngăn xếp phụ trợ:

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

Dịch chuyển hàng này rất hữu ích cho việc chơi golf khi bạn muốn bắt đầu với một lượng lớn mã tuyến tính.

Tiếp theo chúng ta đọc đầu vào và đẩy các bon chính xác:

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

Bit bên trái với ba NOP gửi kết quả âm tính dọc theo nhánh trên cùng và kết quả không âm dọc theo nhánh dưới cùng. Ở bên phải họ được nối lại với nhau.

Bây giờ đi theo một phần tuyến tính lớn khác (có thể được đánh gôn rất nhiều với một mẹo chuyển hàng khác):

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

Điều này đẩy phần còn lại của những chiếc xe lên chồng phụ.

Tiếp theo, chúng tôi tính toán min(20, input), tương tự như nhánh đầu tiên:

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

Cuối cùng, chúng ta có vòng lặp chạy ba lần để in các dòng. Mỗi lần lặp của vòng lặp chứa hai vòng lặp nhỏ (3x3) để in các khoảng trắng, cũng như hai phần để in 6 ký tự từ ngăn xếp phụ:

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

Một mẹo tiện lợi mà tôi muốn thu hút sự chú ý là .{.{.ở cạnh phải. Đây là một ngõ cụt, do đó, .ở cuối, mã được thực thi hai lần, một lần tiến và một lần lùi. Điều này cung cấp một cách gọn gàng để rút ngắn mã palindromic (điều cần lưu ý là bạn cần đảm bảo IP thực hiện lần lượt chính xác khi thoát khỏi ngõ cụt một lần nữa).

Python 2.7, 167 164 159 byte

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

Điều này có đầu vào từ stdin.
Demo tại đây
Kiểm tra điều này -

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

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

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

R, 191 byte

Về tốt như tôi có thể nhận được nó bây giờ. Mất vài giây từ STDIN và mèo đến 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')

Giải trình

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

Xét nghiệm

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

Bản giới thiệu

Ung dung:

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

Bản giới thiệu

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

Mã được hiển thị ở đây trên 3 dòng để phù hợp với bố cục của hộp mã. Những dòng mới là không cần thiết.

Mã không mã hóa:

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

Nó nhận được số giây từ dòng lệnh (đối số đầu tiên):

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

Tùy chọn CLI PHP -d error_reporting=0là cần thiết để ẩn một số thông báo PHP hiển thị về các hằng số không xác định ( str_repeat, _) mà nó chuyển đổi thành chuỗi (được lưu 2 byte cho mỗi thông báo).

Một byte bổ sung có thể được lưu trên PHP 7 bằng cách nén việc khởi tạo $fvào lần sử dụng đầu tiên của nó ( $m=($f=str_repeat)(...)); nó không biên dịch trên PHP 5.

Có thể tìm thấy trường hợp thử nghiệm và một số kỹ thuật được sử dụng để thu nhỏ mã github .

Cập nhật:

@ ismail-Miguel đã siết chặt việc khởi tạo $leftvà $cđưa vào các đối số echolưu 4 byte (xem bình luận bên dưới).

Bằng cách hoán đổi thứ tự các biến $mvà sđược khởi tạo, tôi đã thoát khỏi một cặp dấu ngoặc đơn và lưu thêm 1 byte nữa.

JavaScript (ES6), 121 byte

Sử dụng chuỗi mẫu, 2 dòng mới bên trong chuỗi có ý nghĩa và được tính.

Để lưu byte, xuất ra alert, ngay cả khi phông chữ tỷ lệ được sử dụng alertkhông phù hợp với nghệ thuật ASCII và kết quả là xấu cho n> = 20 (sự cố).

Kiểm tra chạy đoạn mã trong 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

Điều này sử dụng mã thoát ANSI để đặt con trỏ vào đúng vị trí để vẽ những chiếc xe. Sau đó, nó sẽ kiểm tra xem liệu đầu vào có phải là 20 hay không, nếu có, nó sẽ quay trở lại và rút ra trên các nắp ca-pô của xe.

Đưa một int từ stdin, xuất ra 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)

Ung dung:

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

Bình thường, 67 byte

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

Hãy thử nó ở đây .

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

vô dụng:

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

chương trình kiểm tra:

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

đầu ra:

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

Tôi đã có thể chơi golf này khá khó khăn. Tôi nghĩ rằng tôi đã bắt đầu với gần 300 byte.

Nhưng tôi không biết nếu điều này vẫn đáp ứng tất cả các yêu cầu. Như bạn có thể thấy sau 21 giây, chiếc xe đầu tiên đẩy chiếc xe thứ hai sang phải. Tôi sẽ cần thêm một vài byte nếu điều này không được phép.

Chỉnh sửa: đã sửa nó. Điều này nên thực tế hơn Sharknado ;-)

Chỉnh sửa: Tôi có thể rút ngắn đáng kể giải pháp của mình bằng cách xem lại trang thứ hai printf. Nếu bạn sử dụng '*', bạn có thể cung cấp độ dài trường trực tiếp cho printf mà không cần phải tạo chuỗi định dạng sprintftrước.

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

Tôi đã giảm kích thước RẤT NHIỀU, tôi ngạc nhiên rằng tôi đã giảm được một nửa kích thước. Cái cũ ở dưới. Đây không phải là hiệu suất hiệu quả khôn ngoan do độ rộng của lưới, chủ yếu là từ dòng đầu tiên.

Bạn có thể kiểm tra nó ở đây . Đặt lượng thời gian đã trôi qua trong "Ngăn xếp ban đầu", chứ không phải "Đầu vào"!

Đây là phiên bản cũ.

: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 ký tự

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

Không chơi gôn

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

Các kết quả

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

Khá đơn giản. Đối với mỗi hàng của chiếc xe, chúng tôi in lại các nkhoảng trắng, hàng đó, 60-3*nkhoảng trắng và hàng đó một lần nữa. Để dừng xe, thay vì làm min(n,20), đó là một char ngắn hơn để hạn chế lần chạy đầu tiên của không gian với[:20] , và lần thứ hai là tốt vì một lần âm là một chuỗi là chuỗi rỗng.

Để di chuyển lên chắn bùn, chúng tôi chỉ cần làm một replace. Vì __cũng xuất hiện trên mái nhà, chúng tôi cần một chút bối cảnh để xác định chắn bùn, vì vậy chúng tôi kiểm tra các mục /sau.

Java, 270 267 byte

Khá chắc chắn rằng có một cách tốt hơn / ngắn hơn để làm điều này, nhưng bộ não của tôi không tham gia đúng cách.

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

Với n = 19:

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

Với n = 20:

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

Bị đánh cắp

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;

Sử dụng:

Lưu dưới dạng ANSI trong file.php(nên có các ký tự có độ rộng bằng 0 $o) và chạy:

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

với xsố giây.

Và một phiên bản hoạt động mà không thay đổi báo cáo lỗi ( 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

Nó không phải là một người chiến thắng, nhưng nó là một cái gì đó

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