Кто не любит боевики с быстрыми шумными автомобилями, особенно те, где много аварий? Кто не любит боевики в ascii art?

Сцена это:

Две машины стартуют на противоположных сторонах прямой дороги (с 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-

... мой новый двухмерный лабиринт esolang! Приведенный выше код не очень хорошо подходит для игры в гольф (есть 161 пробел и 25 NOP, поэтому лучшая компоновка может значительно сократить это), но, по крайней мере, мне удалось показать, что язык пригоден для нетривиальных задач. :)

Как это работает

Сначала краткий обзор языка:

• Лабиринт работает на два стека, основной и вспомогательный , которые могут содержать произвольные целые числа со знаком. В нижней части обоих стеков есть бесконечное количество нулей.
• Команды - это отдельные символы в двумерной сетке, и они образуют лабиринт (то есть неизвестные символы, особенно пробелы, являются стенами). "это 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}

Бит слева с тремя 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.

Один изящный трюк, на который я хотел бы обратить внимание - .{.{.это правый край. Это тупик, поэтому, кроме .конца, код выполняется дважды, один раз вперед и один раз назад. Это дает аккуратный способ сократить палиндромный код (выгода заключается в том, что вам нужно убедиться, что 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("//","\/")

Это требует ввода от стандартного ввода.
Демо здесь
Тестирование этого -

$ ./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*

демонстрация

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

демонстрация

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

Параметр CLI PHP -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 байт

Используя строку шаблона, 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 байт

При этом используются escape-коды 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)

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 байт

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

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

тестовая программа:

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предварительно создавать строку формата .

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

Un-Golfed

  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. Так как __также появляется на крыше, нам нужно немного контекста, чтобы идентифицировать крылья, поэтому мы проверяем /следующее.

Ява, 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

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 байт

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