Scrivi un programma che accetta un numero intero N tramite stdin o la riga di comando.

Se N è 0, la singola lettera Odeve essere stampata su stdout.

Se N è positivo , è necessario stampare questa doppia elica orizzontale ASCII , disegnata con N segmenti larghi.

Se N è 1, l'output è:

 /\
O  O
 \/

Se N è 2, l'output è:

 /\ /\
O  /  O
 \/ \/

Se N è 3, l'output è:

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

Se N è 4, l'output è:

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

Il modello continua allo stesso modo per i più grandi N. Nota che la barra ( /) deve essere usata in tutti i punti in cui le eliche si incrociano, ad eccezione delle Oestremità.

Se N è negativo , deve essere stampata questa doppia elica di arte ASCII verticale , disegnata con segmenti N-alti.

Se N è -1, l'output è:

 O
/ \
\ /
 O

Se N è -2, l'output è:

 O
/ \
\ /
 \
/ \
\ /
 O

Se N è -3, l'output è:

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

Se N è -4, l'output è:

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

Il motivo continua allo stesso modo per i più piccoli N. Nota che le barre rovesciate ( \) devono essere utilizzate in tutti i punti in cui le eliche si incrociano, tranne le Oestremità.

Dettagli

• Invece di un programma, è possibile scrivere una funzione che accetta N come numero intero e stampa il risultato normalmente o lo restituisce come stringa.
• L'output per qualsiasi N può contenere facoltativamente una nuova riga finale.
• Qualsiasi riga di output per qualsiasi N può facoltativamente contenere 4 o meno spazi finali.
• Non dovrebbe mai esserci spazio iniziale che non faccia parte del modello specificato.
• Vince il codice più breve in byte.

CJam, 56 55 53 52 50 byte

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

Guarda che taglia! I principali colpevoli sono il N = 0caso speciale e \invece che /nell'elica verticale.

Ecco come funziona:

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.

Il codice è diviso in tre parti:

• La parte X0>"\/"=" / \\\ / "+fornisce uno "/ / \\\ / "o "\ / \\\ / "che è cruciale in quanto l'elica è semplicemente composta da alternati "/ \"e "\ /"uniti da uno " / "o " \ ". Ad esempio, se consideri l'input come 2, allora la tua stringa ripetuta finale sarebbe "/ / \\ / / / \\ / "(senza escape). Questo ovviamente ha un extra /all'inizio e uno spazio extra alla fine.
• La seconda parte è correggere la stringa sopra con cose aggiuntive e dividere. Per un input 2, la stringa finale desiderata senza newline sarebbe " O / \\\ / / / \\\ / O", ma dopo il punto sopra, abbiamo solo "/ / \\\ / / / \\\ / ". Quindi rimuoviamo il primo personaggio, aggiungiamo uno spazio e 'Oall'inizio e un altro 'Oalla fine. Quindi abbiamo finalmente diviso in parti di 3
• Infine, decidiamo se trasporre questa stringa divisa per un'elica verticale oppure no; Unire le parti da newline; E scegli tra questo e un singolo carattere 'O(per il caso input 0)

Provalo online qui

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>

Utilizzando una stringa basata su modelli, le nuove righe contano.

Più leggibile

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 byte

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

Dimostrazione.

Spiegazione:

La prima sezione, M[Jj"/\\"*hGdjP*G+*2dH*2\O_J)definisce una funzione g, che accetta due input. Il primo input, Gè il numero di ripetizioni da utilizzare. Questo è il valore assoluto dell'ingresso. Il secondo input, Hè il personaggio da posizionare al centro delle spirali.

La funzione restituisce un elenco di 3 elementi, costituito dalle 3 linee della spirale positiva e dalle 3 colonne della spirale negativa.

Il primo elemento è definito da Jj"/\\"*hGd. *hGdè la stringa di G+1spazi. j"/\\"*hGdunisce quella stringa "/\"come delimitatore. JL'all'inizio salva il valore risultante per un utilizzo futuro.

Il secondo elemento è jP*G+*2dH*2\O. Iniziamo con +*2dH. Si tratta di due spazi seguiti dal carattere di input. Quindi, ripetiamo quella stringa Gvolte con *G. Quindi, rimuoviamo il suo carattere finale con P. Infine, circondiamo questa stringa con due Ocaratteri, con j ... *2\O.

Il terzo elemento viene generato con _J. Questo è semplicemente il contrario della prima riga.

Quest'ultima sezione, ?jb?gQ\/>Q0msdCg_Q\\Q\Oseleziona tra tre diverse possibilità, positiva, negativa e zero. Il primo if-then si accende Q, l'input. La seconda condizione attiva >Q0, se l'ingresso è positivo.

Se Qè zero , viene stampato \Oil carattere O.

Se Qè diverso da zero, ci uniamo al risultato del secondo ternario su newline e lo stampiamo, con jb. Se Qè positivo, la lista uniti e stampati è gQ\/, g(Q,"/").

Se Qè negativo, l'elenco unito e stampato è msdCg_Q\\. Iniziamo con g_Q\\, che è g(-Q,"\"). Quindi trasponiamo le righe e le colonne con C. msdtrasforma le risultanti tuple di caratteri in stringhe, pronte per essere unite su nuove righe e stampate.

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)

Crea la doppia elica verticale da un elenco di stringhe e la traspone per ottenere quella orizzontale. Sono sicuro che potrebbe essere migliorato.

Java, 500 488 byte

Il mio primo tentativo, e sfortunatamente è 10 * più lungo dell'attuale leader :(. Qualcuno ha qualche consiglio (oltre a usare una lingua diversa)?

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 byte

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

Puoi quindi scriverlo come:

*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

Spinto dal commento di Martin , ecco il mio primo tentativo in qualcosa del genere:

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

Più 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 byte

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

Versione non golfata:

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

L'idea è quella di costruire la visualizzazione orizzontale dalla visualizzazione verticale mediante il rendering della matrice trasposta dei caratteri.

Python 3, 118 byte

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

La mia prima presentazione di golf in codice, quindi potrebbe non essere affatto impressionante.

Usa solo l'operatore ternario ... se ... altro ... di Python per separare i tre scenari. Questo dà una stringa fatta di ripetere alcune stringhe più piccole un certo numero di volte per la stampa.

Julia, 229 byte

Oh uomo, questo è il modo, modo troppo grande. È la risposta più lunga finora con un ampio margine. Probabilmente potrei risparmiare molto restituendo la stringa piuttosto che stampandola o evitando del tutto l'approccio a matrice. Lo sperimenterò più tardi.

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)

Questo crea una funzione lambda che accetta un singolo intero e stampa la doppia elica opportunamente formattata. Per chiamarlo, dagli un nome, ad es f=n->(...).

Ungolfed + spiegazione:

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 paio di esempi:

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

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

Python 3, 135 byte

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

Provalo online qui

Perl, 91 97

Il recepimento si è rivelato troppo costoso alla fine.

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

Soluzione precedente:

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

Metti alla prova me .

Schema, 379 byte

Il mio primo tentativo di code golf e, sfortunatamente, uno dei più lunghi. :(

(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

Il mio primo approccio, con nomi di variabili particolarmente piacevoli:

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

_{Non ho idea del perché lo stia facendo. Deve essere qualcosa di ricreativo.}

Java, 317

Il mio primo tentativo di golf a codice.

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 byte

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

Provalo online qui .

Perl, 193 197 187 180 166 163B

Penalità di 1 byte per l'opzione -n ​​della riga di comando. Esegui 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 spazi bianchi:

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

Versione 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 byte

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

Il mio primo tentativo di code golf. Penso che funzioni ma non è sottile.

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 legato con Python 2!

Carbone , 28 24 22 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

↙O

Stampa la parte superiore Oe lascia il cursore uno spazio in basso e a sinistra.

Ｆ↔θ/¶\¶ \¶

Stampa le corde /, \e  \e ripetere per il valore numerico assoluto dell'ingresso.

↗

Torna indietro sull'ultimo \.

‖Ｂ

Rifletti per creare il lato destro dell'elica. Lo faccio qui perché altrimenti ↗non verrebbero analizzati in modo inequivocabile.

O

Sovrascrivi l'ultimo \con un O.

¿›Ｎ⁰⟲Ｔ

Se l'input è stato positivo, ruotare la tela.

Tela , 33 32 30 byte

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

Provalo qui!

Spiegazione:

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

Non è la risposta più breve, ma la prima in C ++ finora :)

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

Qui è in C ++ Shell con spazi bianchi da testare

perl 156

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

Tentativo piuttosto diretto, il mio secondo golf. Penso che le newline contino come 1 byte giusto?

Ora per capire come unire tutti quei ternari insieme ... Ho molto spazio per migliorare con quelli :'';ovunque.

C, 189 byte

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 spazi bianchi e nuove righe:

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

Alcune note sull'approccio:

• Memorizza il modello in matrici di caratteri. Sono spostati di 22 personaggi per evitare di aver bisogno di un mucchio di barre rovesciate per sfuggire a personaggi speciali.
• Utilizza motivi separati per orizzontale, verticale e zero. Inizialmente ho preso in considerazione l'utilizzo di un singolo modello e lo ho attraversato in modo diverso per valori positivi e negativi. Non l'ho implementato, ma avevo la sensazione che avrebbe reso la logica un po 'più complicata. Soprattutto perché la barra centrale ha la direzione opposta per i due casi. E i tavoli non sono così grandi, quindi questo sembrava più promettente.
• Il codice è principalmente solo calcoli dell'indice, con la logica per decidere quando è fatto e quando il modello si muove. Gran parte della matematica è lì in modo che funzioni per entrambi i casi con le loro diverse dimensioni e regole di ripetizione.

Perl, 184 byte

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

Pensavo che sarebbe stato molto più breve! Probabilmente ci sono alcune cose semplici che posso fare per salvare qualche byte. Sono passati cinque anni da quando ho programmato seriamente in 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 byte

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

Provalo online!