Escriba un programa que tome un entero N a través de stdin o la línea de comando.

Si N es 0, la letra única Odebe imprimirse en stdout.

Si N es positivo , se debe imprimir esta doble hélice de arte ASCII horizontal , dibujada con N segmentos de ancho.

Si N es 1, la salida es:

 /\
O  O
 \/

Si N es 2, la salida es:

 /\ /\
O  /  O
 \/ \/

Si N es 3, la salida es:

 /\ /\ /\
O  /  /  O
 \/ \/ \/

Si N es 4, la salida es:

 /\ /\ /\ /\
O  /  /  /  O
 \/ \/ \/ \/

El patrón continúa exactamente de la misma manera para N. más grande. Tenga en cuenta que la barra diagonal ( /) debe usarse en todos los lugares donde se cruzan las hélices, excepto en los Oextremos.

Si N es negativo , esta doble hélice vertical ASCII art, dibujada -N segmentos de altura, debe imprimirse.

Si N es -1, la salida es:

 O
/ \
\ /
 O

Si N es -2, la salida es:

 O
/ \
\ /
 \
/ \
\ /
 O

Si N es -3, la salida es:

 O
/ \
\ /
 \
/ \
\ /
 \
/ \
\ /
 O

Si N es -4, la salida es:

 O
/ \
\ /
 \
/ \
\ /
 \
/ \
\ /
 \
/ \
\ /
 O

El patrón continúa exactamente de la misma manera para los N. más pequeños. Tenga en cuenta que las barras inclinadas hacia atrás ( \) deben usarse en todos los lugares en los que se cruzan las hélices, excepto los Oextremos.

Detalles

• En lugar de un programa, puede escribir una función que tome N como un entero e imprima el resultado normalmente o lo devuelva como una cadena.
• La salida para cualquier N puede contener opcionalmente una nueva línea final.
• Cualquier línea de salida para cualquier N puede contener opcionalmente 4 o menos espacios finales.
• Nunca debería haber ningún espacio inicial que no sea parte del patrón especificado.
• El código más corto en bytes gana.

CJam, 56 55 53 52 50 bytes

S'O:Ori:X0>"\/"=" / \\\ / "+Xz*1>O]s3/X"z"<~N*X\O?

Mira ese tamaño! Los principales culpables son N = 0casos especiales y en \lugar de /en la hélice vertical.

Así es como funciona:

S'O:O                                  e# Put a space on stack. Now put char O on stack
                                       e# and assign it to variable O. This is not really
                                       e# helping in golfing as using 'O everywhere is
                                       e# same number of bytes
     ri:X                              e# Read input as in integer and store it in X
         0>"\/"=                       e# If X is greater than 0, choose /, otherwise \
                " / \\\ / "            e# Put this string on stack
                           +           e# Append to chosen \ or /
                            Xz*        e# Repeat it abs(X) times
1>                                     e# Remove the first character from repeated string
  O]                                   e# Put char O on stack, wrap everything in an array
                                       e# and convert it to string.
    3/                                 e# Split the string into parts of length 3
      X"z"<~                           e# If X is positive, transpose the array to get a
                                       e# horizontal helix, otherwise it would be vertical
            N*                         e# Join the parts with newline
              X\O?                     e# If X was 0, then pick char O instead of this
                                       e# final joined string.

El código se divide en tres partes:

• La parte X0>"\/"=" / \\\ / "+da uno "/ / \\\ / "o lo "\ / \\\ / "que es crucial, ya que la hélice está compuesta simplemente por alternativa "/ \"y "\ /"unida por uno " / "o " \ ". Por ejemplo, si considera que la entrada es 2, entonces su cadena repetida final sería "/ / \\ / / / \\ / "(sin escapar). Obviamente, esto tiene un extra /al comienzo y un espacio extra al final.
• La segunda parte es corregir la cadena anterior con cosas adicionales y dividir. Para una entrada 2, la cadena final deseada sin nuevas líneas sería " O / \\\ / / / \\\ / O", pero después del punto anterior, solo tenemos "/ / \\\ / / / \\\ / ". Entonces eliminamos el primer carácter, agregamos un espacio y 'Oal principio y otro 'Oal final. Luego finalmente lo dividimos en partes de 3
• Finalmente, decidimos si transponer esta cadena dividida para una hélice vertical o no; Unir las partes por nuevas líneas; Y elija entre esto y un solo carácter 'O(para el caso de entrada 0)

Pruébalo en línea aquí

JavaScript (ES6), 126 132 133

A=n=>(F=(f,j='')=>f+(j+f).repeat(n-1),n>0?F(' /\\')+`
o${F('  ','/')}o
`+F(' \\/'):(n=-n)?` o${F(`
/ \\
\\ /
`,' \\')} o`:'o') 

// Test
for(i=0;i<10;i++)
  P.innerHTML = P.innerHTML + A(i)+'\n\n\n',
  N.innerHTML = N.innerHTML + A(-i)+'\n\n\n'

pre { 
  font-size: 10px;
  line-height: 9px;
}

<table>
<tr><th>Positive</th><th>Negative</th></tr>
<tr><td valign=top><pre id=P></pre></td><td><pre id=N></pre></td></tr>
</table>

Usando una cadena con plantilla, las nuevas líneas cuentan.

Más legible

A=n=>(
  F=(f,j='')=>f+(j+f).repeat(n-1),
  n > 0 ? F(' /\\') + '\no' + F('  ','/') + 'o\n'+F(' \\/')
  : (n=-n) ? ' o' + F('\n/ \\\n\\ /\n',' \\')'+' o':'o'
)  

Pyth, 52 bytes

M[Jj"/\\"*hGdjP*G+*2dH*2\O_J)?jb?gQ\/>Q0msdCg_Q\\Q\O

Demostración.

Explicación:

La primera sección, M[Jj"/\\"*hGdjP*G+*2dH*2\O_J)define una función g, que toma dos entradas. La primera entrada, Ges el número de repeticiones a usar. Este es el valor absoluto de la entrada. La segunda entrada, Hes el carácter a colocar en el centro de las espirales.

La función devuelve una lista de 3 elementos, que consta de las 3 líneas de la espiral positiva y las 3 columnas de la espiral negativa.

El primer elemento está definido por Jj"/\\"*hGd. *hGdes la cadena de G+1espacios j"/\\"*hGdune esa cadena con "/\"el delimitador. Al Jprincipio guarda el valor resultante para uso futuro.

El segundo elemento es jP*G+*2dH*2\O. Comenzamos con +*2dH. Estos son dos espacios seguidos del carácter de entrada. Luego, repetimos esa secuencia Gveces con *G. Luego, eliminamos su carácter final con P. Finalmente, rodeamos esta cadena con dos Ocaracteres, con j ... *2\O.

El tercer elemento se genera con _J. Esto es simplemente el reverso de la primera línea.

La última sección, ?jb?gQ\/>Q0msdCg_Q\\Q\Oselecciona entre tres posibilidades diferentes, positiva, negativa y cero. Las primeras condiciones si-entonces Q, la entrada. La segunda condición >Q0, si la entrada es positiva.

Si Qes cero, \Oel personaje O, se imprime.

Si Qno es cero, unimos el resultado del segundo ternario en las nuevas líneas y lo imprimimos con jb. Si Qes positivo, se unió a la lista e impreso es gQ\/, g(Q,"/").

Si Qes negativo, la lista unida e impresa es msdCg_Q\\. Comenzamos con g_Q\\, que es g(-Q,"\"). Luego transponemos las filas y columnas con C. msdconvierte las tuplas de caracteres resultantes en cadenas, listas para unirse en líneas nuevas e impresas.

Pitón 2, 118

n=input()
a=[' O '[n==0:]]+['/ \\','\\ /','  /\\ '[n<0::2]]*abs(n)
a[-1]=a[0]
for x in[a,zip(*a)][n>0]:print''.join(x)

Crea la doble hélice vertical a partir de una lista de cadenas y la transpone para obtener la horizontal. Estoy seguro de que podría mejorarse.

Java, 500 488 bytes

Mi primer intento, y desafortunadamente es 10 * más largo que el líder actual :(. ¿Alguien tiene algún consejo (aparte de usar un idioma diferente)?

import java.util.*;class t{public static void main(String[] args){Scanner sc=new Scanner(System.in);int n=Integer.parseInt(sc.nextLine());if(n>0){for(int i=0;i<n;i++)System.out.print(" /\\");o("");System.out.print('o');for(int i=0;i<n-1;i++)System.out.print("  /");o("  o");for(int i=0;i<n;i++)System.out.print(" \\/");}else if(n<0){o(" o ");for(int i=0;i<-n-1;i++){o("/ \\");o("\\ /");o(" \\ ");}o("/ \\");o("\\ /");o(" o ");}else o("o");}static void o(String s){System.out.println(s);}}

Haskell, 156 bytes

h 0="O"
h n|n>0=' ':c n "/\\ "++"\nO"++c(n-1)"  /"++"  O\n "++c n "\\/ "
   |0<1=" O\n/ \\\n"++c(-n-1)"\\ /\n \\\n/ \\\n"++"\\ /\n O"
c x=concat.replicate x

Luego puede escribirlo como:

*Main> putStrLn $ h 1
 /\ 
O  O
 \/ 
*Main> putStrLn $ h 0
O
*Main> putStrLn $ h (-1)
 O
/ \
\ /
 O
*Main> putStrLn $ h 3
 /\ /\ /\ 
O  /  /  O
 \/ \/ \/ 
*Main> putStrLn $ h (-3)
 O
/ \
\ /
 \
/ \
\ /
 \
/ \
\ /
 O
*Main>

C #, 242 241 238 230 222 219 Bytes

Estimulado por el comentario de Martin , aquí está mi primer intento de algo como esto:

string h(int n){int x=0;string p="",r=n==0?"O":p;if(n>0){for(;x++<n;){r+=" /\\";p+=" \\/";}r+="\nO  ";for(;x-->2;)r+="/  ";r+="O\n"+p;}else if(n<0){r+=@" O
/ \
";for(--x;x-->n;)r+=@"\ /
 \
/ \
";r+=@"\ /
 O";}return r;}

Más legible:

string h(int n)
{
    int x = 0;
    string p = "",
            r = n==0 ? "O" : p;
    if (n > 0) {
        for (; x++ < n;) {
            r += " /\\";
            p += " \\/";
        }
        r += "\nO  ";
        for (; x-- > 2;) r += "/  ";
        r += "O\n" + p;
    }
    else if(n<0) {
        r += @" O
/ \
";
        for (--x; x-- > n;) r += @"\ /
 \
/ \
";
        r += @"\ /
 O";
    }
    return r;
}

C # 199 197 196 bytes

string f(int n){var u=n<0;int m=u?-n:n;string a="",b=" O ";for(;m-->0;)b+="\n/ \\\n\\ /\n "+(m==0?"O ":u?"\\ ":"/ ");for(;++m<3;)a+=string.Concat(b.Split('\n').Select(s=>s[m]))+"\n";return u?b:a;}

Versión sin golf:

    string f(int n)
    {
        var u = n < 0;
        int m = u ? -n : n;
        string a = "", b = " O ";
        for (; m-- > 0; ) b += "\n/ \\\n\\ /\n " + (m == 0 ? "O " : u ? "\\ " : "/ ");
        for (; ++m < 3;) a += string.Concat(b.Split('\n').Select(s => s[m])) + "\n"; 
        return u ? b : a;
    }

La idea es construir la visualización horizontal a partir de la visualización vertical renderizando la matriz de caracteres transpuesta.

Python 3, 118 bytes

x=int(input())
print("O"if x==0else" /\\"*x+"\nO "+" / "*(x-1)+" O\n"+" \\/"*x if x>0else(" O"+"\n/ \\\n\\ /\n \\"*-x)[:-1]+"O")

Mi primer envío de código de golf, por lo que puede no ser del todo impresionante.

Solo usa el operador ternario ... if ... else ... de Python para separar los tres escenarios. Eso le da a una cadena hecha de repetir algunas cadenas más pequeñas un cierto número de veces para imprimir.

Julia, 229 bytes

Oh hombre, esto es cierto, manera demasiado grande. Es la respuesta más larga hasta ahora por un amplio margen. Probablemente podría ahorrar mucho devolviendo la cadena en lugar de imprimirla, o evitando el enfoque de matriz por completo. Experimentaré con eso más tarde.

n->(if n==0 println("O")else m=abs(n);A=B=reshape(split(" / "*(n>0?"/":"\\")*" \\\\ /",""),(3,3));E=[" ";"O";" "];if m>1for i=2:m B=hcat(B,A)end end;B[:,1]=E;B=hcat(B,E);C=n>0?B:B';for i=1:size(C,1) println(join(C[i,:]))end end)

Esto crea una función lambda que toma un solo entero e imprime la doble hélice con el formato adecuado. Para llamarlo, dale un nombre, por ejemplo f=n->(...).

Ungolfed + explicación:

function f(n)
    if n == 0
        println("O")
    else
        m = abs(n)

        # Split the string into a 3x3 matrix with a slash on the left,
        # or a backslash for n < 0
        A = B = reshape(split(" / " * (n > 0 ? "/" : "\\") * " \\\\ /", ""), (3, 3))

        # We can get the O lines where needed by appending this
        E = [" "; "O"; " "]

        # Grow the helix by abs(n)
        if m > 1
            for i = 2:m
                B = hcat(B, A)
            end
        end

        # Exchange the first column for E
        B[:,1] = E

        # Add E onto the right
        B = hcat(B, E)

        # If n is negative, we actually want the transpose
        C = n > 0 ? B : B'

        # Print the rows of C
        for i = 1:size(C, 1)
            println(join(C[i,:]))
        end
    end
end

Un par de ejemplos:

julia> f(1)
 /\
O  O
 \/

julia> f(-2)
 O 
/ \
\ /
 \
/ \
\ /
 O

Python 3, 135 bytes

n=int(input());m=abs(n)-1;print({n:" O\n/ \\\n"+m*"\ /\n \\\n/ \\\n"+"\\ /\n O",m+1:n*" /\\"+"\nO"+"  /"*m+"  O\n"+" \/"*n,0:"O"}[n])

Pruébalo en línea aquí

Perl, 91 97

La transposición resultó ser demasiado costosa al final.

#!perl -n
print/-/?"\0\23"^" \\
/ \\
\\ /
"x-$_." O":-$_?" /\\"x$_.("*`"^" / "x$_." O
"." \\/"x$_):O

Solución previa:

#!perl -n
$".="`"^"/ 
\\ /
/ \\
 "x abs.O;print/-/?$"=~y!/\\!\\/!r:/^0/?O:map{($"=~/^.{$_}(.)/mg,$/)}2,1,0

Ponme a prueba .

Esquema, 379 bytes

Mi primer intento de codificar golf y, desafortunadamente, uno de los más largos. :(

(define (h i) (define a string-append) (define (k n p q s e) (cond ((= i n) (p s (k (q n 1) p q s e))) ((= 0 n) e) (else (p `("\\ /" ,(if (> i 0) " / " " \\") "/ \\") (k (q n 1) p q s e))))) (if (= i 0) "O\n" (apply a (map (lambda (s) (a s "\n")) (if (> i 0) (k i (lambda (x y) (map a x y)) - '(" /" "O " " \\") '("\\" " O" "/")) (k i append + '(" O" "/ \\") '("\\ /" " O")))))))

Sin golfizar:

(define (h i)
  (define a string-append)

  (define (k n p q s e)
    (cond ((= i n) (p s (k (q n 1) p q s e)))
          ((= 0 n) e)
          (else (p `("\\ /" ,(if (> i 0) " / " " \\") "/ \\")
                   (k (q n 1) p q s e)))))

  (if (= i 0) "O\n"
      (apply a (map (lambda (s) (a s "\n"))
                    (if (> i 0)
                        (k i (lambda (x y) (map a x y)) -
                           '(" /" "O " " \\")
                           '("\\" " O" "/"))
                        (k i append +
                           '(" O" "/ \\")
                           '("\\ /" " O")))))))

Java, 282

Mi primer enfoque, con nombres de variables particularmente agradables:

class H{public static void main(String[]_){int N=Integer.parseInt(_[0]),í=N;String ì="/ \\\n\\ /\n",I=" o \n",i="",l=I;for(;í-->0;)i+=" /\\";i+="\no";for(í=N;í-->1;)i+="  /";i+="  o\n";for(í=N;í-->0;)i+=" \\/";for(í=1;í++<-N;)l+=ì+" \\ \n";System.out.println(N<0?l+ì+I:N>0?i:"o");}}

_{No tengo idea de por qué estoy haciendo esto. Debe ser algo recreativo.}

Java, 317

Mi primer intento de golf de código.

public class t{public static void main(String[]e){int n=Integer.parseInt(e[0]);String s=new String(new char[n==0?0:(n>0?n:-n)-1]),u="\0";System.out.print(n==0?"O":n>0?s.replace(u," /\\")+" /\\\nO"+s.replace(u,"  /")+"  O\n"+s.replace(u," \\/")+" \\/":" O \n/ \\\n"+s.replace(u,"\\ /\n \\ \n/ \\\n")+"\\ /\n O \n");}}

Python 3, 165 bytes

x,a,b,c,d=int(input())-1,'\ /',' / ','/ \\','\ /\n \\\n/ \\\n'
print([[' O\n/ \\\n'+d*abs(x+2)+'\ /\n O',' /'+a*x+'\\\nO '+b*x+' O\n \\'+c*x+'/'],'OO'][x==-1][x>-1])

Pruébelo en línea aquí .

Perl, 193 197 187 180 166 163B

Penalización de 1 byte para el interruptor de línea de comando -n. Correr con echo 1|perl -M5.10.0 -n scratch.pl:

$_*=3;$s=($m=abs)==$_;$_?map{say if$_=join'',map{(map[/./g]," O ",(('/ \\', '\\ /',$s?' / ':' \\ ')x$m)[0..$m-2]," O")[$s?$_:$j][$s?$j:$_]}0..$m;$j++}0..$m:say'O'

Con espacios en blanco:

$_ *= 3;
$s = ($m = abs) == $_;
$_ ? map{
      say if $_=join '', map {
       ( map[/./g],
          " O ",
          (('/ \\', '\\ /',$s?' / ':' \\ ') x $m)[0..$m-2],
          " O"
        )[$s ? $_ : $j][$s ? $j : $_]
       }0..$m;
      $j++
    } 0..$m
  : say 'O'

PHP, 341

$s='';$n=$argv[1];$l=PHP_EOL;if($n>0){for($i=0;$i<$n;$i++)$s.=" /\\";$s.=$l;for($i=0;$i<$n;$i++){if($i==0)$s.='o';if($i<$n-1)$s.='  /';if($i==$n-1)$s.='  o';}$s.=$l;for($i=0;$i<$n;$i++)$s.=" \\/";}else{$n=abs($n);for($i=0;$i<$n;$i++){if($i== 0)$s.=' o '.$l;$s.="/ \\".$l."\\ /".$l;if($i < $n-1)$s.=' \\ '.$l;if($i==$n-1)$s.=' o '.$l;}}echo $s;

Versión sin golf

$s = '';
$n = $argv[1];
echo PHP_EOL;
if($n > 0)
{
    for($i=0;$i<$n;$i++)
    {
        $s.=" /\\";
    }
    $s.=PHP_EOL;

    for($i=0;$i<$n;$i++)
    {
        if($i==0) { 
            $s.='o';
        }
        if($i < $n-1) {
            $s.='  /';
        }    
        if( $i == $n-1)
        {
            $s.='  o';
        }
    }
    $s.=PHP_EOL;

    for($i=0;$i<$n;$i++)
    {
        $s.=" \\/";
    }
} else
{
    $n = abs($n);
    for($i=0;$i<$n;$i++)
    {
        if($i == 0) {
            $s.=' o '.PHP_EOL;    
        }    
        $s.="/ \\".PHP_EOL."\\ /".PHP_EOL;
        if($i < $n-1) {
            $s.=' \\ '.PHP_EOL;
        }    
        if( $i == $n-1) {
            $s.=' o '.PHP_EOL;
        }    
    }    
}

echo $s;

JAVA 377 384 bytes

class F{public static void main(String[] a){int n=Integer.parseInt(a[0]);if(n>0){for(int i=0;i<n;i++)p(" /\\");p("\n");for(int i=0;i<n;i++){if(i==0)if(n>1)p("O  ");else p("O  O");else if(i==n-1)p("/  O");else p("/  ");}p("\n");for(int i=0;i<n;i++){p(" \\/");}}else{p(" O\n");for(int i=0;i<Math.abs(n);i++){p("/ \\\n\\ /\n O\n");}}}static void p(String s){System.out.print(s);}}

C ++ 269 262 258

#include <string>
#include <iostream>
int main(){int i,j;std::cin>>i;std::string s,u,t;if(i>0){for(j=i;j;j--){s+=" /\\";t+="/  ";u+=" \\/";}t[0]='O';t+="O";s=s+'\n'+t+'\n'+u;}else{for(j=i;j;j++)s+=" \\\n/ \\\n\\ /\n";s[1]='O';s+=" O";}std::cout<<(i==0?"O":s);}

R, 228 201

n=scan();z=cat;f=`for`;if(!n)z("O");if(n>0){f(i,1:n,z(" /\\"));z("\nO  ");if(n>1)f(i,2:n,z("/  "));z("O\n");f(i,1:n,z(" \\/"))};if(n<0){z(" O\n");f(i,-n:1,{z("/ \\\n\\ /\n ");if(i>1)z("\\\n")});z("O")}

Mi primer intento de código de golf. Creo que funciona pero no es sutil.

n=scan(); # enter number here
z=cat;
if(!n) z("O\n");
if(n>0){
  z(" ");
  for(i in 1:n) z("/\\ ");
  z("\nO");
  if(n>1){
    for(i in 2:n) z("  /")
  };
  z("  O\n ");
  for(i in 1:n) z("\\/ ")
};
if(n<0){
  z(" O \n");
  for(i in -n:1){
    z("/ \\\n\\ /");
    if(i>1) z("\n \\\n")
  };
z("\n O ")
}

Groovy, 142 134 129 125 120 118

a=args[0]as int;b="\n/ \\\n\\ /\n ";print!a?"O":a>0?" /\\"*a+"\nO  ${"/  "*(a-1)}O\n"+" \\/"*a:" O$b${"\\$b"*(1-a)}O"

Finalmente atado con python 2!

Carbón , 28 24 22 bytes

↙OＦ↔θ/¶\¶ \¶↗‖ＢO¿›Ｎ⁰⟲Ｔ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

↙O

Imprima la parte superior Oy deje el cursor un espacio hacia abajo y hacia la izquierda.

Ｆ↔θ/¶\¶ \¶

Imprimir las cuerdas /, \y  \y repita para el valor del número absoluto de la entrada.

↗

Retroceder sobre el último \.

‖Ｂ

Reflexiona para crear el lado derecho de la hélice. Hago esto aquí porque de lo contrario ↗no se analizaría sin ambigüedades.

O

Sobrescriba el último \con un O.

¿›Ｎ⁰⟲Ｔ

Si la entrada fue positiva, gire el lienzo.

Lienzo , 33 32 30 bytes

 /¶O：╴⤢╷\ /¶ \×＋；↔＋──╴０＜？↷｝╴‽O

Pruébalo aquí!

Explicación:

 /¶O:                           push " /\¶O" twice
     ╴⤢╷                        push the absolute value of the input, -1
        \ /¶ /×                 repeat "\ /¶ /" horizontally that many times
               ＋                append that horizontally to one of the first strings
                ;               and get the other, reverse it
                 ↔+             and then append it to the result of above. Now the top part of the helix is done
                   ──           vertically palindromize with no mirroring (works because of a misake - it just doesn't overlap smartly)
                     ╴0<? }     if the input is less than 0
                         ↷        rotate clockwise the whole thing
                           ╴‽   if the input is falsy (aka 0)
                             O    push O; implicitly output the top of stack

C ++, 352

No es la respuesta más corta, pero es la primera en C ++ hasta ahora :)

#include <iostream>
int main(int argc, char* argv[]){int a=argv[0][0]-'0';if(a==0){printf("o");}else if(a>0){for(int i =0; i < a;i++){printf(" /\\");}printf("\no");for(int i=0;i<a-1;i++){printf("  /");}printf("  o\n");for(int i=0;i<a;i++){printf(" \\/");}}else{printf(" o\n/ \\\n\\ /\n");for(int i=0;i>a+1;i--){printf("/ \\\n\\ /\n");}printf(" o");};}

Aquí está en C ++ Shell con espacios en blanco para probar

perl 156

$==pop;print$=>0?' /\\'x$=.$/:'',$=>0?'O'.'  /'x$=."\bO
":'',$=>0?' \\/'x$=:'';print$=<0?" O":'';print"
/ \\
\\ /
 \\" for$=..-1;print$=<0?"\bO":!$=?"O":''

Intento bastante sencillo, mi segundo golf. Creo que las nuevas líneas cuentan como 1 byte, ¿verdad?

Ahora para descubrir cómo unir todos esos ternaries juntos. Tengo mucho margen de mejora con aquellos en :'';todas partes.

C, 189 bytes

char*h="6Er66 e66Ee 6rE66",*v="6e6 E6r r6E 6r6 6e6",*z="e",*u;b,m,w,c,p;f(n){b=n<0;u=b?v:n?h:z;for(m=b?4:1,w=n*(b?-3:3);u[p];p+=++c%((w+2)*m)==w*m?m:p%(6*m)==m*4?-m*3:0)putchar(u[p++]-22);}

Con espacios en blanco y líneas nuevas:

char *h="6Er66 e66Ee 6rE66",
     *v="6e6 E6r r6E 6r6 6e6",
     *z="e",
     *u;
b, m, w, c, p;
f(n) {
    b = n < 0;
    u = b ? v : n ? h : z;
    for (m = b ? 4 : 1, w = n * (b ? - 3 : 3);
         u[p];
         p += ++c % ((w + 2) * m) == w * m ? m : p % (6 * m ) == m * 4 ? - m * 3 : 0)
        putchar(u[p++] - 22);
 }

Algunas notas sobre el enfoque:

• Almacena el patrón en matrices de caracteres. Están desplazados por 22 caracteres para evitar la necesidad de un montón de barras invertidas para escapar de caracteres especiales.
• Utiliza patrones separados para horizontal, vertical y cero. Inicialmente consideré usar un solo patrón y solo recorrerlo de manera diferente para valores positivos y negativos. No lo implementé, pero tuve la sensación de que haría la lógica un poco más complicada. Particularmente porque la barra central tiene la dirección opuesta para los dos casos. Y las mesas no son tan grandes, así que esto parecía más prometedor.
• El código es principalmente solo cálculos de índice, con lógica para decidir cuándo se hace y cuándo se repite el patrón. Gran parte de la matemática está ahí para que funcione para ambos casos con sus diferentes dimensiones y reglas de repetición.

Perl, 184 bytes

$n=pop;$p=$n>0;$_=' \ /'x(1+abs$n*3);$n=$p?$n*4+1:3;$_=join'
',/.{$n}/g;$r=$p?'.':'.*
';s/($r$r)$r($r)/$1$2/g;$p and s/^\S|\S$/O/gm or s/^ \S $|(?<=^ )\S|\S $/O/g;y~\\/~/\\~if$p;print;

¡Pensé que esto sería mucho más corto! Probablemente hay algunas cosas simples que puedo hacer para guardar algunos bytes. ¡Han pasado cinco años desde que programé seriamente en Perl!

PHP, 155

$n=$argv[1];$r='str_repeat';$k="/ \\\n\\ /\n";echo$n>0?" /{$r('\ /',$n-1)}\\\nO{$r('  /',$n-1)}  O\n \\{$r('/ \\',$n-1)}/":" O\n{$r("$k \\\n",-$n-1)}$k O";

J , 67 59 55 51 bytes

(<&0|:' O '(0},[)(3,~3*|)$' / \\'({~,7$[)0,*) ::'O'

Pruébalo en línea!