빠른 시끄러운 자동차, 특히 충돌이 많은 자동차의 액션 영화를 좋아하지 않는 사람은 누구입니까? 아스키 아트에서 누가 액션 샷을 좋아하지 않습니까?

장면은 다음과 같습니다

직선 도로 반대편에서 두 대의 차량이 운행 중입니다 (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-

... 내 새로운 2 차원에 솔랑 미로! 위의 코드는 엄청나게 골프를 타지 못했지만 (161 개의 공백과 25 개의 NOP가 있으므로 더 나은 레이아웃으로이를 많이 줄일 수 있습니다), 적어도 언어가 사소한 작업에 사용할 수 있음을 보여주었습니다. :)

작동 원리

먼저 언어에 대한 간단한 개요 :

• Labyrinth는 main 및 secondary의 두 스택에서 작동하며 임의의 부호있는 정수를 보유 할 수 있습니다. 두 스택의 맨 아래에는 무한한 양의 0이 있습니다.
• 명령은 2D 그리드의 개별 문자이며 미로를 형성합니다 (알 수없는 문자, 특히 공백)는 벽입니다. "NOP는 벽이 아니며 코드의 특정 경로를 채우는 데 도움이 될 수 있습니다. 다른 많은 2D 언어와 달리 가장자리가 줄 바꿈 되지 않습니다 .
• 명령어 포인터 (IP)는 벽이 아닌 첫 번째 문자 (읽기 순서)가 오른쪽으로 이동하면 시작됩니다. @프로그램을 종료합니다.
• 가능하면 IP는 복도를 따라갑니다 (구부러짐 주위). IP에 이동할 셀이 여러 개있는 경우 기본 스택의 상단이 음수이면 일반적으로 왼쪽으로 돌아가고, 0이면 직진하거나, 양수이면 오른쪽으로 돌립니다. IP가 벽에 닿으면 방향이 바뀝니다. (미묘한 부분이 몇 개 더 있지만이 코드에는 문제가되지 않습니다.) 제어 흐름을 구현하는 유일한 방법입니다.
• 산술 및 스택 조작 명령 외에도 소스 코드 >v<^의 행 또는 열을 한 셀씩 주기적으로 이동시키는 네 개의 명령으로 런타임에 소스 코드를 수정할 수 있습니다 . 영향을받는 행 또는 열은 스택 상단에 따라 다릅니다. IP의 자체 행 또는 열이 이동되면 이동과 함께 이동합니다. 이를 통해 소스 코드의 한쪽 끝에서 다른 쪽 끝으로 이동할 수 있습니다.

이 특별한 도전에 대한 일반적인 알고리즘은 다음과 같습니다.

• 차량 끝을 보닛 (예 :)까지 / \_o oo o보조 스택 위로 밉니다 .
• 입력을 읽고 푸시할지 __또는 /\다음 을 결정하십시오 .
• 나머지 차량 (예 : __ __ _/ \두 개의 선행 공간)을 보조 스택에 밀어 넣습니다 .
• 입력을 최대 값으로 고정 20하고 이것을 N 이라고합시다 .
• 이제 다음 3 번을 수행하십시오.
  • N 개의 공백을 인쇄 하십시오.
  • 6 개의 저장된 문자를 인쇄하십시오.
  • 60-3 * N 공백을 인쇄 하십시오.
  • 6 개의 저장된 문자를 인쇄하십시오.
  • 줄 바꿈을 인쇄하십시오.

마지막으로 코드의 일부를 살펴 보겠습니다. IP는 그리드 이동 명령에서 왼쪽 상단에서 시작합니다. 메인 스택의 상단은 0(상대 인덱스로 사용됨) 첫 번째 행이 왼쪽으로 이동하여 IP를 그리드의 오른쪽 끝으로 이동합니다. 이제 첫 번째 행은 오른쪽에서 왼쪽으로 간단하게 실행되어 첫 번째 고정 문자 세트를 보조 스택으로 푸시합니다.

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

이 행 이동은 대량의 선형 코드로 시작하려는 경우 골프에 유용합니다.

다음으로 입력을 읽고 올바른 보닛을 밀어 넣습니다.

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

3 개의 NOP가있는 왼쪽의 비트는 상단 분기를 따라 음의 결과를 보내며 하단 분기를 따라 음이 아닌 결과를 보냅니다. 오른쪽에서 그들은 다시 합쳐집니다.

이제 또 다른 큰 선형 섹션을 따르십시오 (아마도 다른 행 이동 트릭으로 골프를 칠 수 있음).

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

이것은 나머지 차량을 보조 스택으로 밀어 넣습니다.

다음으로 우리 min(20, input)는 첫 번째 브랜치와 비슷한를 계산합니다

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

마지막으로, 우리는 선을 인쇄하기 위해 세 번 반복되는 루프를 가지고 있습니다. 루프의 각 반복에는 공백을 인쇄하기위한 두 개의 작은 (3x3) 루프와 보조 스택에서 6자를 인쇄하는 두 개의 섹션이 있습니다.

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

내가 주목하고 싶은 멋진 트릭 .{.{.은 오른쪽 가장자리입니다. 이것은 막 다른 길이이므로 .끝에서 코드를 두 번, 한 번 앞으로, 한 번 뒤로 실행합니다. 이것은 palindromic 코드를 깔끔하게 정리할 수있는 방법을 제공합니다 (데드 엔드를 다시 종료 할 때 IP가 올바른 방향으로 돌아가도록해야합니다).

파이썬 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 줄로 표시됩니다. 그 줄 바꿈이 필요하지 않습니다.

ungolfed 코드 :

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

PHP CLI 옵션 -d error_reporting=0은 PHP가 문자열로 변환하는 정의되지 않은 상수 ( str_repeat, _) 에 대해 표시하는 일부 통지를 숨겨야합니다 (각 통지에 대해 2 바이트 저장).

초기화를 $f첫 번째 사용으로 압축하여 PHP 7에 추가 바이트를 저장할 수 있습니다 ( $m=($f=str_repeat)(...)). PHP 5에서는 컴파일되지 않습니다.

테스트 사례와 코드 축소에 사용 된 기술 중 일부는 github 에서 찾을 수 있습니다 .

최신 정보:

@ ismail-miguel는 4 바이트 를 절약 하는 인수를 초기화 $left하고 인라인 $c했습니다 echo(아래 주석 참조).

순서에게 변수를 교환함으로써 $m및 s초기화 나는 한 쌍의 괄호를 제거했고, 1 바이트 이상의 저장.

자바 스크립트 (ES6), 121 바이트

템플릿 문자열을 사용하면 문자열 내부의 두 줄 바꿈이 중요하고 계산됩니다.

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>

파이썬 2, 148 바이트

이것은 ANSI 이스케이프 코드를 사용하여 자동차를 그릴 올바른 위치에 커서를 놓습니다. 그런 다음 입력이 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 맨 페이지 를 다시 살펴보면 솔루션을 크게 단축 할 수 있습니다 . '*'를 사용하면 sprintf미리 format-string을 만들 필요없이 필드 길이를 printf에 직접 제공 할 수 있습니다 .

> <> , 538 276 바이트

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

자바, 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      

파이썬 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. __지붕에도 나타나기 때문에 펜더를 식별하기 위해 약간의 컨텍스트가 필요하므로 /다음을 확인하십시오 .

자바, 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(에 0 문자가 있어야 함 $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;

자바 스크립트, 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"))
}