Quem não gosta de filmes de ação com carros velozes e barulhentos, especialmente aqueles com muitos acidentes? Quem não ama cenas de ação na arte ascii?

A cena é:

Dois carros estão começando em lados opostos de uma estrada reta (com 60 espaços no meio). Eles começam a dirigir um para o outro em velocidades constantes. O carro à esquerda dirige a 1 espaço por segundo e o carro à direita dirige a 2 espaços por segundo.

Obviamente, os carros não podem passar um pelo outro, então n ≥ 20, a cena será dois carros batidos com capotas na posição em que o acidente ocorreu.

Como amante de filmes, quero pausar a cena de vez em quando, apenas para apreciar a beleza dela.

Dado um número inteiro n(argumento da função ou STDIN), representando o número de segundos desde o início da cena, mostre a cena naquele momento.

Esta é a cena inicial, com 60 espaços entre as rodas dianteiras:

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

esta é a cena após 11 segundos:

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

e é assim que parece após o acidente (observe que as capotas estão abertas após o acidente):

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

Eu só estou interessado em assistir dois carros batendo, então espaços, novas linhas ++ não importam.

Este é o código golf, portanto o código mais curto em bytes vence. As respostas adicionadas mais tarde ainda podem vencer se forem mais curtas que a resposta atualmente aceita.

CJam, 68 66 bytes

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

Experimente online

Quem vê o início do código terá certeza liKedisso!

Explicação:

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.

Labirinto , 394 386 bytes

Eu orgulhosamente apresento ...

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

... meu novo labirinto esolang bidimensional! O código acima não é incrivelmente bom (existem 161 espaços e 25 NOPs, portanto, um layout melhor pode reduzir muito isso), mas pelo menos eu consegui mostrar que o idioma é utilizável para tarefas não triviais. :)

Como funciona

Primeiro, uma rápida visão geral do idioma:

• O labirinto opera em duas pilhas, principal e auxiliar , que podem conter números inteiros assinados arbitrariamente. Na parte inferior das duas pilhas, há uma quantidade infinita de zeros.
• Os comandos são caracteres individuais em uma grade 2D e formam um labirinto (caracteres desconhecidos, principalmente espaços, são paredes). "é um NOP que não é uma parede e pode ser útil para preencher determinados caminhos no código. Ao contrário de muitas outras linguagens 2D, as bordas não se enrolam.
• O ponteiro de instrução (IP) começa com o primeiro caractere que não é de parede (em ordem de leitura) movendo-se para a direita. @finaliza o programa.
• Se possível, o IP segue corredores (também em torno de curvas). Se o IP tiver várias células para mover, geralmente vira à esquerda se a parte superior da pilha principal for negativa, seguirá em frente se for zero ou vire à direita se for positivo. Quando o IP atinge uma parede, ele inverte a direção. (Existem mais algumas sutilezas, mas elas não devem importar para esse código.) Essa é a única maneira de implementar o fluxo de controle.
• Além dos comandos aritméticos e de manipulação de pilha, o código fonte pode ser modificado em tempo de execução com os quatro comandos >v<^que deslocam uma linha ou coluna do código fonte ciclicamente por uma célula. A linha ou coluna afetada depende da parte superior da pilha. Se a própria linha ou coluna do IP for alterada, ela se moverá com a mudança. Isso torna possível pular de uma borda do código fonte para a outra.

Agora, para este desafio em particular, aqui está a ideia geral do algoritmo:

• Empurre as extremidades dos carros até as capotas (ou seja / \_o oo o) na pilha auxiliar.
• Leia a entrada e determine se deve pressionar __ou a /\seguir.
• Empurre o restante dos carros (ou seja, __ __ _/ \dois espaços à esquerda) na pilha auxiliar.
• Prenda a entrada no valor máximo de 20, vamos chamar isso de N .
• Agora faça o seguinte 3 vezes:
  • Imprima N espaços.
  • Imprima 6 caracteres armazenados.
  • Imprima 60 - 3 * N espaços.
  • Imprima 6 caracteres armazenados.
  • Imprima uma nova linha.

Por fim, vejamos algumas partes do código. O IP inicia no canto superior esquerdo, em um comando de mudança de grade. A parte superior da pilha principal é 0(que é usada como um índice relativo); portanto, a primeira linha é deslocada para a esquerda, o que também move o IP para a extremidade direita da grade. Agora, a primeira linha é simplesmente executada da direita para a esquerda, o que coloca o primeiro conjunto de caracteres fixos na pilha auxiliar:

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

Essa mudança de linha é útil para jogar golfe quando você deseja iniciar com uma grande quantidade de código linear.

Em seguida, lemos a entrada e pressionamos os capôs ​​corretos:

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

O bit à esquerda com os três NOPs envia resultados negativos ao longo do ramo superior e não negativos ao longo do ramo inferior. À direita, eles se juntam novamente.

Agora segue outra seção linear grande (que provavelmente poderia ser muito jogada com outro truque de mudança de linha):

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

Isso empurra o restante dos carros para a pilha auxiliar.

Em seguida, computamos min(20, input), que é semelhante ao primeiro ramo:

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

Finalmente, temos o loop que é executado três vezes para imprimir as linhas. Cada iteração do loop contém dois pequenos loops (3x3) para imprimir os espaços, bem como duas seções para imprimir 6 caracteres da pilha auxiliar:

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

Um truque bacana que eu gostaria de chamar a atenção é o .{.{.da borda direita. Esse é um beco sem saída, portanto, além do .final, o código é executado duas vezes, uma para frente e outra para trás. Isso fornece uma maneira clara de reduzir o código palindrômico (o problema é que você precisa garantir que o IP tome a curva correta ao sair do beco sem saída novamente).

Python 2.7, 167 164 159 bytes

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

Isso leva a entrada de stdin.
Demonstração aqui
Testando isso -

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

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

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

R, 191 bytes

Tão bom quanto eu posso conseguir agora. Leva os segundos de STDIN e gatos para 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')

Explicação

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

Testes

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

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

Demo

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

Demo

PHP, 160 155 bytes

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

O código é exibido aqui em 3 linhas para ajustar o layout da caixa de código. Essas novas linhas não são necessárias.

O código não destruído:

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

Obtém o número de segundos da linha de comando (primeiro argumento):

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

A opção CLI do PHP -d error_reporting=0é necessária para ocultar alguns avisos que o PHP exibe sobre constantes indefinidas ( str_repeat, _) que ele converte em strings (2 bytes salvos para cada aviso).

Um byte adicional pode ser salvo no PHP 7 pressionando a inicialização $fno seu primeiro uso ( $m=($f=str_repeat)(...)); não compila no PHP 5.

O caso de teste e algumas das técnicas usadas para reduzir o código podem ser encontradas no github .

Atualizar:

@ ismail-miguel reduziu a inicialização $lefte incluiu $cos argumentos de echosalvar 4 bytes (veja o comentário abaixo).

Ao trocar a ordem das variáveis $me ssão inicializadas, me livrei de um par de parênteses e economizei 1 byte a mais.

JavaScript (ES6), 121 bytes

Usando a sequência de modelo, as duas novas linhas dentro da sequência são significativas e contadas.

Para salvar bytes, imprima com alert, mesmo que a fonte proporcional usada alertnão seja adequada para a arte ASCII e o resultado seja feio para n> = 20 (falha).

Teste a execução do snippet no 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 bytes

Isso usa códigos de escape ANSI para posicionar o cursor no lugar certo para desenhar os carros. Em seguida, verifica se a entrada foi 20, se foi, volta e usa as capotas do carro.

Retorna um int de stdin, output para 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/\\"

Pitão, 67 bytes

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

Experimente aqui .

                                                                       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 bytes

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

programa de teste:

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

saída:

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

Eu era capaz de jogar golfe com bastante força. Eu acho que comecei com quase 300 bytes.

Mas não sei se isso ainda cumpre todos os requisitos. Como você pode ver após 21 segundos, o primeiro carro empurra o segundo carro para a direita. Eu precisaria adicionar alguns bytes se isso não for permitido.

Edit: corrigido. Isso deve ser mais realista do que Sharknado ;-)

Editar: eu poderia reduzir significativamente minha solução dando uma segunda olhada na printfpágina de manual. Se você usar '*', poderá fornecer o comprimento do campo diretamente para printf, sem a necessidade de criar sprintfpreviamente uma string de formato .

> <> , 538 276 bytes

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

Eu perdi muito o tamanho, estou surpreso por ter conseguido diminuir o tamanho pela metade. O antigo está abaixo. Este não é tão eficiente quanto ao desempenho devido à largura da grade, principalmente da primeira linha.

Você pode testá-lo aqui . Coloque a quantidade de tempo passada na "Pilha Inicial", não na "Entrada"!

Aqui está a versão antiga.

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

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

Resultados

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 bytes

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

Bem direto. Para cada linha do carro, imprimimos nespaços, essa linha, 60-3*nespaços e a linha novamente. Para parar os carros, em vez de fazermin(n,20) , era um caractere mais curto para limitar a primeira corrida de espaços com[:20] , e o segundo é bom porque um número negativo de vezes que uma sequência é a sequência vazia.

Para subir as defesas, nós apenas fazemos a replace. Como __também aparece no telhado, precisamos de um pouco de contexto para identificar os pára-lamas, portanto, verificamos o /seguinte.

Java, 270 267 bytes

Tenho certeza de que há uma maneira melhor / mais curta de fazer isso, mas meu cérebro não está devidamente envolvido.

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

Para n = 19:

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

Para 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 bytes

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

Uso:

Salve como ANSI em file.php(deve haver caracteres de largura zero $o) e execute:

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

com xo número de segundos.

E uma versão que funciona sem alterar o relatório de erros ( 148 bytes ):

<?$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 bytes

Não é um vencedor, mas é algo

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