¿A quién no le gustan las películas de acción con autos rápidos y ruidosos, especialmente aquellos con muchos accidentes? ¿Quién no ama las tomas de acción en el arte ascii?

La escena es:

Dos autos comienzan en lados opuestos de una carretera recta (con 60 espacios entre ellos). Comienzan a conducir uno hacia el otro a velocidades constantes. El automóvil a la izquierda conduce a 1 espacio por segundo, y el de la derecha conduce a 2 espacios por segundo.

Obviamente, los autos no pueden cruzarse entre sí, por lo que n ≥ 20la escena será dos autos chocados con capó en la posición donde ocurrió el accidente.

Como amante del cine, quiero pausar la escena de vez en cuando, solo para disfrutar de su belleza.

Dado un número entero n(argumento de función o STDIN), que representa el número de segundos desde el comienzo de la escena, muestra la escena en ese momento.

Esta es la escena inicial, con 60 espacios entre las ruedas delanteras:

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

Esta es la escena después de 11 segundos:

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

y esto es lo que parece después del bloqueo (tenga en cuenta que los capó están arriba después del bloqueo):

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

Solo estoy interesado en ver dos autos chocando, por lo que los espacios, las nuevas líneas, ++ no importan.

Este es el código de golf, por lo que gana el código más corto en bytes. Las respuestas agregadas más tarde aún pueden ganar si son más cortas que la respuesta actual aceptada.

CJam, 68 66 bytes

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

Pruébalo en línea

¡Cualquiera que vea el inicio del código lo asegurará liKe!

Explicación:

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.

Laberinto , 394386 bytes

Os presento con orgullo ...

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

... mi nuevo laberinto bidimensional esolang! El código anterior no es increíblemente bueno (hay 161 espacios y 25 NOP, por lo que un mejor diseño podría acortar mucho esto), pero al menos logré demostrar que el lenguaje es utilizable para tareas no triviales. :)

Cómo funciona

Primero, una descripción rápida del idioma:

• Labyrinth opera en dos pilas, principal y auxiliar , que pueden contener enteros con signo arbitrario. En la parte inferior de ambas pilas hay una cantidad infinita de ceros.
• Los comandos son caracteres individuales en una cuadrícula 2D y forman un laberinto (es decir, los caracteres desconocidos, particularmente los espacios, son paredes). "es un NOP que no es un muro y puede ser útil para rellenar ciertas rutas en el código. A diferencia de muchos otros lenguajes 2D, los bordes no se ajustan.
• El puntero de instrucción (IP) comienza en el primer carácter no mural (en orden de lectura) que se mueve hacia la derecha. @termina el programa
• Si es posible, la IP sigue los corredores (también alrededor de las curvas). Si la IP tiene varias celdas a las que moverse, generalmente girará a la izquierda si la parte superior de la pila principal es negativa, avanzará si es cero o girará a la derecha si es positiva. Cuando el IP golpea una pared, invierte la dirección. (Hay algunas sutilezas más, pero no deberían importar este código). Esta es la única forma de implementar el flujo de control.
• Además de los comandos de manipulación aritmética y de pila, el código fuente puede modificarse en tiempo de ejecución con los cuatro comandos >v<^que desplazarán una fila o columna del código fuente cíclicamente por una celda. La fila o columna afectada depende de la parte superior de la pila. Si la propia fila o columna de la IP se desplaza, se moverá con el cambio. Esto hace posible saltar de un borde del código fuente al otro.

Ahora para este desafío particular, aquí está la idea general del algoritmo:

• Empuje los extremos de los automóviles hasta los capó (es decir / \_o oo o) en la pila auxiliar.
• Lea la entrada y determine si presionar __o el /\siguiente.
• Empuje el resto de los automóviles (es decir, __ __ _/ \y dos espacios principales) en la pila auxiliar.
• Sujetar la entrada a un valor máximo de 20, Llamemos a esto N .
• Ahora haga lo siguiente 3 veces:
  • Imprimir N espacios.
  • Imprime 6 caracteres almacenados.
  • Imprimir 60 - 3 * N espacios.
  • Imprime 6 caracteres almacenados.
  • Imprime una nueva línea.

Finalmente, veamos algunas partes del código. La IP comienza en la esquina superior izquierda, en un comando de cambio de cuadrícula. La parte superior de la pila principal es 0(que se usa como índice relativo), por lo que la primera fila se desplaza hacia la izquierda, lo que también mueve la IP al extremo derecho de la cuadrícula. Ahora la primera fila simplemente se ejecuta de derecha a izquierda, lo que empuja el primer conjunto de caracteres fijos a la pila auxiliar:

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

Este cambio de fila es útil para jugar al golf cuando desea comenzar con una gran cantidad de código lineal.

A continuación, leemos la entrada y empujamos los sombreros correctos:

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

El bit de la izquierda con los tres NOP envía resultados negativos a lo largo de la rama superior y resultados no negativos a lo largo de la rama inferior. A la derecha se vuelven a unir.

Ahora sigue otra sección lineal grande (que probablemente podría jugar mucho con otro truco de cambio de fila):

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

Esto empuja el resto de los autos a la pila auxiliar.

A continuación, calculamos min(20, input), que es similar a la primera rama:

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

Finalmente, tenemos el bucle que se ejecuta tres veces para imprimir las líneas. Cada iteración del bucle contiene dos bucles pequeños (3x3) para imprimir los espacios, así como dos secciones para imprimir 6 caracteres desde la pila auxiliar:

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

Un ingenioso truco al que me gustaría llamar la atención es .{.{.en el borde derecho. Este es un callejón sin salida, por lo que, aparte del .final, el código se ejecuta dos veces, una hacia adelante y otra hacia atrás. Esto proporciona una forma ordenada de acortar el código palindrómico (el problema es que debe asegurarse de que la IP tome el giro correcto cuando salga del callejón sin salida nuevamente).

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

Esto toma la entrada de stdin.
Demostración aquí
Probar esto -

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

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

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

R, 191 bytes

Tan bueno como puedo conseguirlo ahora. Lleva los segundos de STDIN y gatos a 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')

Explicació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')

Pruebas

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

Manifestación

Sin golf:

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

Manifestación

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

El código se muestra aquí en 3 líneas para adaptarse al diseño del cuadro de código. Esas nuevas líneas no son necesarias.

El código sin golf:

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

Obtiene el número de segundos de la línea de comando (primer argumento):

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

La opción CLI de PHP -d error_reporting=0es necesaria para ocultar algunos avisos que muestra PHP sobre constantes indefinidas ( str_repeat, _) que convierte en cadenas (2 bytes guardados para cada aviso).

Se puede guardar un byte adicional en PHP 7 apretando la inicialización $fen su primer uso ( $m=($f=str_repeat)(...)); no se compila en PHP 5.

El caso de prueba y algunas de las técnicas utilizadas para reducir el código se pueden encontrar en github .

Actualizar:

@ ismail-miguel exprimió la inicialización $lefte $cincorporó los argumentos de echoguardar 4 bytes (ver comentario más abajo).

Al intercambiar el orden de las variables $my sse inicializan, eliminé un par de paréntesis y guardé 1 byte más.

JavaScript (ES6), 121 bytes

Usando la cadena de plantilla, las 2 nuevas líneas dentro de la cadena son significativas y contadas.

Para guardar bytes, alertimprima con , incluso si la fuente proporcional utilizada alertno es adecuada para el arte ASCII y el resultado es feo para n> = 20 (bloqueo).

Prueba de ejecutar el fragmento en 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

Esto usa códigos de escape ANSI para colocar el cursor en el lugar correcto para dibujar los autos. Luego verifica si la entrada fue 20, si lo fue, retrocede y se basa en los capó del automóvil.

Toma un int de stdin, salida a 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)

Sin golf:

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 bytes

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

Pruébalo aquí .

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

sin golf:

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

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

salida:

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

Pude jugar golf bastante duro. Creo que comencé con casi 300 bytes.

Pero no sé si esto aún cumple con todos los requisitos. Como puede ver después de 21 segundos, el primer automóvil empuja el segundo automóvil hacia la derecha. Necesitaría agregar algunos bytes si esto no está permitido.

Editar: lo arregló. Esto debería ser más realista que Sharknado ;-)

Editar: podría acortar significativamente mi solución al echar un segundo vistazo a la printfpágina de manual. Si usa '*', puede suministrar la longitud del campo directamente a printf, sin la necesidad de crear una cadena de formato de sprintfantemano.

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

He bajado mucho el tamaño, estoy sorprendido de haber logrado reducir el tamaño a la mitad. El viejo está abajo. Este no es tan eficiente en cuanto al rendimiento debido al ancho de la cuadrícula, principalmente desde la primera línea.

Puedes probarlo aquí . ¡Ponga la cantidad de tiempo transcurrido en la "Pila inicial", no en la "Entrada"!

Aquí está la versión anterior.

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

Sin golf

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

Muy claro. Para cada fila del automóvil, imprimimos nespacios, esa fila, 60-3*nespacios y la fila nuevamente. Para detener los autos, en lugar de hacerlo min(n,20), fue un carácter más corto limitar la primera serie de espacios [:20], y el segundo está bien porque un negativo multiplicado por una cadena es la cadena vacía.

Para subir las defensas, solo hacemos a replace. Como __también aparece en el techo, necesitamos un poco de contexto para identificar los guardabarros, por lo que buscamos un /seguimiento.

Java, 270 267 bytes

Estoy bastante seguro de que hay una forma mejor / más corta de hacer esto, pero mi cerebro no está correctamente comprometido.

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

Sin golf

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:

Guardar como ANSI en file.php(debe haber caracteres de ancho cero $o) y ejecutar:

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

con x como el número de segundos.

Y una versión que funciona sin cambiar el informe de errores ( 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

No es un ganador, pero es 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"))
}