Хто не любить бойовики з швидкими галасливими автомобілями, особливо з великими аваріями? Хто не любить кадри екшн у мистецтві 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.

Лабіринт , 394 386 байт

Я з гордістю представляю ...

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

... мій новий двовимірний лабіринт езолангу! Наведений вище код не є надзвичайно добре гольф (є 161 пробіл та 25 НОП, тому краща компонування може це значно скоротити), але принаймні мені вдалося показати, що мова використовується для нетривіальних завдань. :)

Як це працює

По-перше, короткий огляд мови:

• Лабіринт функціонує на двох стеках, основній та допоміжної , які можуть містити довільні цілі числа. Внизу обох стеків є нескінченна кількість нулів.
• Команди - це окремі символи на 2D сітці, і вони утворюють лабіринт (тобто невідомі символи, зокрема пробіли, - це стіни). "це NOP, який не є стіною і може бути корисним для прокладки певних контурів у коді. На відміну від багатьох інших 2D мов краї не обмотуються.
• Покажчик інструкцій (IP) починається з першого символу, який не є стінним (у порядку читання), рухаючись праворуч. @припиняє програму.
• Якщо можливо, IP слід за коридорами (також навколо вигинів). Якщо в IP є кілька комірок для переміщення, він, як правило, поверне ліворуч, якщо верхня частина основного стека є негативною, рухайтеся прямо вперед, якщо вона дорівнює нулю, або поверніть праворуч, якщо вона додатна. Коли 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}

Біт ліворуч із трьома НОП посилає негативні результати по верхній гілці та негативні результати по нижній гілці. Справа вони з'єднані назад.

Тепер слідує ще один великий лінійний розділ (який, мабуть, можна було б отримати в гольф за допомогою іншого трюку, який змінює ряд):

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

Це штовхає решту автомобілів на допоміжний штабель.

Далі ми обчислюємо min(20, input), що схоже на першу гілку:

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

Нарешті, у нас є цикл, який тричі працює для друку рядків. Кожна ітерація циклу містить дві невеликі (3x3) петлі для друку пробілів, а також два розділи для друку 6 символів із допоміжного стеку:

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

Один чудовий трюк, на який я хотів би звернути увагу, - .{.{.це правий край. Це глухий кут, тому крім .кінцевого кінця код виконується двічі, один раз вперед і один раз назад. Це дає чіткий спосіб скоротити паліндромний код (суперечка полягає в тому, що вам потрібно переконатися, що ІР приймає правильний поворот при повторному виході з тупику).

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

Параметр PHP CLI -d error_reporting=0потрібен, щоб приховати деякі повідомлення PHP-дисплеїв про невизначені константи ( str_repeat, _), які вони перетворюють на рядки (2 байти, збережені для кожного повідомлення).

Один додатковий байт можна зберегти на PHP 7, видавивши ініціалізацію $fв його перше використання ( $m=($f=str_repeat)(...)); він не компілюється на PHP 5.

Тестовий випадок та деякі методи, що використовуються для зменшення коду, можна знайти на github .

Оновлення:

@ ismail-miguel видавив ініціалізацію $leftта вклав $cу аргументи echoзбереження 4 байтів (див. коментар нижче).

Замінивши порядок змінних $mі sініціалізувавшись, я позбувся пари дужок і врятував ще 1 байт.

JavaScript (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>

Python 2, 148 байт

Для цього використовуються коди аварійних відхилень ANSI, щоб розташувати курсор у потрібному місці для малювання автомобілів. Потім він перевіряє, чи був вхід 20, якщо він був, він повертається назад і затягує капоти автомобіля.

Бере int від stdin, виводить на 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 секунду, перша машина штовхає другу машину вправо. Мені потрібно додати кілька байтів, якщо це не дозволено.

Редагувати: виправити. Це має бути більш реалістично, ніж Шаркнадо ;-)

Редагувати: Я міг би значно скоротити своє рішення, поглянувши на сторінку printfчоловіка. Якщо ви використовуєте "*", ви можете подати довжину поля безпосередньо до printf, не потрібно sprintfзаздалегідь створювати рядок формату .

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

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