Escreva um programa que receba um número inteiro N via stdin ou pela linha de comando.

Se N for 0, a letra única Odeverá ser impressa em stdout.

Se N for positivo , essa dupla hélice horizontal ASCII art , desenhada com N segmentos de largura, deve ser impressa.

Se N for 1, a saída é:

 /\
O  O
 \/

Se N for 2, a saída é:

 /\ /\
O  /  O
 \/ \/

Se N for 3, a saída é:

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

Se N for 4, a saída é:

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

O padrão continua exatamente da mesma maneira para N. maior. Observe que a barra ( /) deve ser usada em todos os lugares em que as hélices se cruzam, exceto nas Oextremidades.

Se N for negativo , essa dupla hélice vertical ASCII art, com segmentos -N altos, deve ser impressa.

Se N for -1, a saída é:

 O
/ \
\ /
 O

Se N for -2, a saída é:

 O
/ \
\ /
 \
/ \
\ /
 O

Se N for -3, a saída é:

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

Se N for -4, a saída é:

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

O padrão continua exatamente da mesma maneira para N. menor. Observe que as barras invertidas ( \) devem ser usadas em todos os lugares em que as hélices se cruzam, exceto nas Oextremidades.

Detalhes

• Em vez de um programa, você pode escrever uma função que recebe N como um número inteiro e imprime o resultado normalmente ou o retorna como uma sequência.
• A saída para qualquer N pode opcionalmente conter uma nova linha à direita.
• Qualquer linha de saída para qualquer N pode opcionalmente conter 4 ou menos espaços à direita.
• Nunca deve haver espaço à esquerda que não faça parte do padrão especificado.
• O código mais curto em bytes vence.

CJam, 56 55 53 52 50 bytes

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

Olhe para esse tamanho! Os principais culpados são N = 0casos especiais e, em \vez de /na hélice vertical.

Aqui está 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.

O código é dividido em três partes:

• A parte X0>"\/"=" / \\\ / "+fornece um "/ / \\\ / "ou o "\ / \\\ / "que é crucial, pois a hélice é simplesmente composta de suplente "/ \"e "\ /"unida por um " / "ou outro " \ ". Por exemplo, se você considera que a entrada é 2, sua sequência final repetida seria "/ / \\ / / / \\ / "(sem escapar). Obviamente, isso tem extra /no começo e um espaço extra no final.
• A segunda parte é corrigir a sequência acima com itens adicionais e dividir. Para uma entrada 2, a sequência final desejada sem novas linhas seria " O / \\\ / / / \\\ / O", mas após o ponto acima, temos apenas "/ / \\\ / / / \\\ / ". Então, removemos o primeiro caractere, adicionamos um espaço e 'Ono começo e outro 'Ono final. Então nós finalmente dividimos em partes de 3
• Finalmente, decidimos se devemos transpor essa cadeia de divisão para uma hélice vertical ou não; Junte as peças por novas linhas; E escolha entre esse e um único caractere 'O(para o caso 0)

Experimente online aqui

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 seqüência de modelo, as novas linhas contam.

Mais legível

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

Pitão, 52 bytes

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

Demonstração.

Explicação:

A primeira seção M[Jj"/\\"*hGdjP*G+*2dH*2\O_J),, define uma função g, que recebe duas entradas. A primeira entrada G,, é o número de repetições a serem usadas. Este é o valor absoluto da entrada. A segunda entrada,, Hé o caractere a ser colocado no centro das espirais.

A função retorna uma lista de 3 elementos, que consiste nas 3 linhas da espiral positiva e nas 3 colunas da espiral negativa.

O primeiro elemento é definido por Jj"/\\"*hGd. *hGdé a sequência de G+1espaços. j"/\\"*hGdune essa string com "/\"o delimitador. O Jno início salva o valor resultante para uso futuro.

O segundo elemento é jP*G+*2dH*2\O. Começamos com +*2dH. São dois espaços seguidos pelo caractere de entrada. Em seguida, repetimos esse Gtempo de sequência com *G. Em seguida, removemos seu caractere final com P. Finalmente, cercamos essa sequência com dois Ocaracteres, com j ... *2\O.

O terceiro elemento é gerado com _J. Isso é simplesmente o inverso da primeira linha.

A última seção ?jb?gQ\/>Q0msdCg_Q\\Q\Oseleciona entre três possibilidades diferentes, positiva, negativa e zero. O primeiro se-então condiciona Qa entrada. A segunda condição é ativada >Q0, se a entrada é positiva.

Se Qfor zero, \Oo caractere Oé impresso.

Se Qfor diferente de zero, juntamos o resultado do segundo ternário em novas linhas e o imprimimos com jb. Se Qfor positivo, a lista se juntou e impresso é gQ\/, g(Q,"/").

Se Qfor negativo, a lista unida e impressa é msdCg_Q\\. Começamos com o g_Q\\que é g(-Q,"\"). Em seguida, transpomos as linhas e colunas com C. msdtransforma as tuplas resultantes de caracteres em seqüências de caracteres, prontas para serem unidas em novas linhas e impressas.

Python 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)

Cria a hélice dupla vertical a partir de uma lista de seqüências de caracteres e a transpõe para obter a horizontal. Tenho certeza que poderia ser melhorado.

Java, 500 488 bytes

Minha primeira tentativa, e infelizmente é 10 * mais longa que o líder atual :(. Alguém tem alguma dica (além de usar um 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

Você pode escrevê-lo 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

Estimulada pelo comentário de Martin , aqui está minha primeira tentativa de algo assim:

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

Mais facilmente:

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

Versão não destruída:

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

A idéia é criar a exibição horizontal a partir da exibição vertical, renderizando a matriz de caracteres transposta.

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

Meu primeiro envio de código de golfe, por isso pode não ser nada impressionante.

Apenas usa o operador ternário do Python ... se ... mais ... para separar os três cenários. Isso fornece uma sequência feita para repetir algumas seqüências menores um certo número de vezes para imprimir.

Julia, 229 bytes

Oh homem, este é o caminho, caminho muito grande. É a resposta mais longa até agora por uma grande margem. Provavelmente, eu poderia economizar muito retornando a string em vez de imprimi-la ou evitando completamente a abordagem matricial. Vou experimentar isso mais 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)

Isso cria uma função lambda que pega um único inteiro e imprime a hélice dupla formatada adequadamente. Para chamá-lo, dê um nome, por exemplo f=n->(...).

Ungolfed + explicação:

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

Alguns exemplos:

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

Experimente online aqui

Perl, 91 97

A transposição provou ser muito cara no final.

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

Solução anterior:

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

Teste- me .

Esquema, 379 bytes

Minha primeira tentativa no código de golfe e, infelizmente, uma das mais longas. :(

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

Ungolfified:

(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

Minha primeira abordagem, com nomes de variáveis ​​particularmente agradáveis:

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

_{Eu não tenho idéia do por que estou fazendo isso. Deve ser algo recreativo.}

Java, 317

Minha primeira tentativa de código de golfe.

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

Experimente online aqui .

Perl, 193 197 187 180 166 163B

Penalidade de 1 byte para a opção de linha de comando -n. Corra com 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'

Com espaço em branco:

$_ *= 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;

Versão ungolfed

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

Minha primeira tentativa no código de golfe. Eu acho que funciona, mas não é 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 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 amarrado com python 2!

Carvão , 28 24 22 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

↙O

Imprima a parte superior Oe deixe o cursor um espaço para baixo e para a esquerda.

Ｆ↔θ/¶\¶ \¶

Imprimir as cordas /, \e  \e repita para o valor do número absoluto da entrada.

↗

Volte sobre o último \.

‖Ｂ

Reflita para criar o lado direito da hélice. Eu faço isso aqui porque, caso contrário ↗, não seria analisado sem ambiguidade.

O

Substitua o último \por um O.

¿›Ｎ⁰⟲Ｔ

Se a entrada foi positiva, gire a tela.

Tela , 33 32 30 bytes

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

Experimente aqui!

Explicação:

 /¶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

Não é a resposta mais curta, mas a primeira em C ++ até agora :)

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

Aqui está no C ++ Shell com espaço em branco para testar

perl 156

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

Tentativa bastante direta, meu segundo golfe. Eu acho que as novas linhas contam como 1 byte, certo?

Agora, para descobrir como unir todos esses ternários ... Eu tenho muito espaço para melhorias com aqueles em :'';todos os lugares.

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

Com espaço em branco e novas linhas:

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

Algumas notas sobre a abordagem:

• Armazena o padrão em matrizes de caracteres. Eles são deslocados em 22 caracteres para evitar a necessidade de várias barras invertidas para escapar de caracteres especiais.
• Usa padrões separados para horizontal, vertical e zero. Inicialmente, considerei usar um único padrão e apenas percorrê-lo de maneira diferente para valores positivos e negativos. Não o implementei, mas tinha a sensação de que isso tornaria a lógica um pouco mais complicada. Especialmente porque a barra central tem a direção oposta para os dois casos. E as mesas não são tão grandes, então isso parecia mais promissor.
• O código é principalmente apenas cálculos de índice, com lógica para decidir quando é feito e quando o padrão faz um loop. Grande parte da matemática existe para que funcione nos dois casos, com diferentes dimensões e regras de repetição.

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;

Eu pensei que isso seria muito mais curto! Provavelmente existem algumas coisas simples que posso fazer para salvar alguns bytes. Faz cinco anos desde que eu programei seriamente em 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'

Experimente online!