Ecrivez un programme qui prend un entier N via stdin ou la ligne de commande.

Si N est 0, la lettre unique Odoit être imprimée sur stdout.

Si N est positif , cette double hélice horizontale ASCII art , N segments larges, doit être imprimée.

Si N est 1, le résultat est:

 /\
O  O
 \/

Si N est 2, le résultat est:

 /\ /\
O  /  O
 \/ \/

Si N est 3, le résultat est:

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

Si N est 4, le résultat est:

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

Le motif continue exactement de la même manière pour les N plus grands. Notez que la barre oblique ( /) doit être utilisée à tous les endroits où les hélices se croisent, à l'exception des Oextrémités.

Si N est négatif , cette double hélice verticale de l’art ASCII, dessinée avec N segments hauts, doit être imprimée.

Si N est -1, le résultat est:

 O
/ \
\ /
 O

Si N est -2, le résultat est:

 O
/ \
\ /
 \
/ \
\ /
 O

Si N est -3, le résultat est:

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

Si N est -4, le résultat est:

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

Le motif continue exactement de la même manière pour les N plus petits. Notez que les barres obliques inversées ( \) doivent être utilisées à tous les endroits où les hélices se croisent, à l'exception des Oextrémités.

Détails

• Au lieu d’un programme, vous pouvez écrire une fonction qui prend N en tant qu’entier et affiche le résultat normalement ou le renvoie sous forme de chaîne.
• La sortie de n'importe quel N peut éventuellement contenir une nouvelle ligne.
• Toute ligne de sortie pour n'importe quel N peut éventuellement contenir 4 espaces de fin ou moins.
• Il ne devrait jamais y avoir d'espace principal qui ne fasse pas partie du modèle spécifié.
• Le code le plus court en octets gagne.

CJam, 56 55 53 52 50 octets

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

Regardez cette taille! Les principaux coupables sont N = 0des cas particuliers et le \lieu de /l'hélice verticale.

Voici comment cela fonctionne:

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.

Le code est divisé en trois parties:

• La partie X0>"\/"=" / \\\ / "+donne soit "/ / \\\ / "ou "\ / \\\ / "qui est crucial car l’hélice est simplement constituée d’alternative "/ \"et "\ /"rejoint par l’un " / "ou l’ autre " \ ". Par exemple, si vous considérez l'entrée comme étant 2, votre dernière chaîne répétée serait "/ / \\ / / / \\ / "(sans échappement). Cela a évidemment plus /au début et un espace supplémentaire à la fin.
• La deuxième partie consiste à corriger la chaîne ci-dessus avec des éléments supplémentaires et à scinder. Pour une entrée 2, la chaîne finale souhaitée sans nouvelles lignes serait " O / \\\ / / / \\\ / O", mais après le point ci-dessus, nous en avons seulement "/ / \\\ / / / \\\ / ". Nous supprimons donc le premier caractère, ajoutons un espace et 'Oau début et un autre 'Oà la fin. Ensuite, nous l'avons scindé en parties de 3
• Enfin, nous décidons de transposer ou non cette chaîne de division pour une hélice verticale; Rejoignez les parties par des nouvelles lignes; Et choisissez entre ceci et un seul caractère 'O(pour la casse saisie 0)

Essayez-le en ligne ici

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>

À l'aide d'une chaîne basée sur un modèle, les nouvelles lignes comptent.

Plus lisible

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 octets

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

Manifestation.

Explication:

La première section, M[Jj"/\\"*hGdjP*G+*2dH*2\O_J)définit une fonction gqui prend deux entrées. La première entrée, Gest le nombre de répétitions à utiliser. C'est la valeur absolue de l'entrée. La deuxième entrée, Hest le caractère à placer au centre des spirales.

La fonction retourne une liste de 3 éléments, composée des 3 lignes de la spirale positive et des 3 colonnes de la spirale négative.

Le premier élément est défini par Jj"/\\"*hGd. *hGdest la chaîne d' G+1espaces. j"/\\"*hGdrejoint cette chaîne avec "/\"comme délimiteur. La valeur Jde départ enregistre la valeur résultante pour une utilisation future.

Le deuxième élément est jP*G+*2dH*2\O. Nous commençons avec +*2dH. Il s’agit de deux espaces suivis du caractère saisi. Ensuite, nous répétons ces Gtemps de chaîne avec *G. Ensuite, on enlève son dernier caractère avec P. Enfin, nous entourons cette chaîne de deux Ocaractères, avec j ... *2\O.

Le troisième élément est généré avec _J. C'est simplement l'inverse de la première ligne.

Cette dernière section ?jb?gQ\/>Q0msdCg_Q\\Q\Osélectionne entre trois possibilités différentes, positive, négative et nulle. Le premier si-alors conditionne Q, l'entrée. La deuxième condition sur >Q0, si l'entrée est positive.

Si Qest égal à zéro, \Ole caractère Oest imprimé.

Si Qest non nul, nous joignons le résultat du deuxième ternaire sur les nouvelles lignes et l’imprimons avec jb. Si Qest positif, la liste jointe et imprimés est gQ\/, g(Q,"/").

Si Qest négatif, la liste jointe et imprimée est msdCg_Q\\. Nous commençons par g_Q\\ce qui est g(-Q,"\"). Ensuite, nous transposons les lignes et les colonnes avec C. msdtransforme les nuplets de caractères résultants en chaînes, prêtes à être jointes sur de nouvelles lignes et imprimées.

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)

Crée la double hélice verticale à partir d'une liste de chaînes et la transpose pour obtenir celle horizontale. Je suis sûr que cela pourrait être amélioré.

Java, 500 488 octets

Mon premier essai, et malheureusement, il est 10 * plus long que le leader actuel :(. Quelqu'un a-t-il des conseils (autres que d'utiliser un langage différent)?

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 octets

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

Vous pouvez ensuite l'écrire comme suit:

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

Sous l'impulsion du commentaire de Martin , voici ma première tentative:

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

Plus lisiblement:

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 octets

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

Version non-golfée:

    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'idée est de construire l'affichage horizontal à partir de l'affichage vertical en rendant la matrice de caractères transposée.

Python 3, 118 octets

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

Ma toute première soumission de golf de code, donc ce n'est peut-être pas du tout impressionnant.

Utilise simplement l'opérateur ... si ... autrement ... de Python pour séparer les trois scénarios. Cela donne une chaîne faite de répéter certaines petites chaînes un certain nombre de fois à imprimer.

Julia, 229 octets

Oh mec, c'est beaucoup trop grand. C'est la réponse la plus longue à ce jour par une large marge. Je pourrais probablement économiser beaucoup en renvoyant la chaîne plutôt qu'en l'imprimant ou en évitant complètement l'approche par matrice. Je ferai des expériences avec ça plus tard.

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)

Cela crée une fonction lambda qui prend un seul entier et imprime la double hélice formatée de manière appropriée. Pour l'appeler, donnez-lui un nom, par exemple f=n->(...).

Ungolfed + explication:

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

Quelques exemples:

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

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

Python 3, 135 octets

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

Essayez-le en ligne ici

Perl, 91 97

La transposition s'est avérée trop chère à la fin.

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

Solution précédente:

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

Testez - moi .

Schéma, 379 octets

Ma première tentative de code de golf et, malheureusement, l’un des plus longs. :(

(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

Ma première approche, avec des noms de variables particulièrement sympathiques:

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

_{Je ne sais pas pourquoi je fais ça. Ça doit être quelque chose de récréatif.}

Java, 317

Ma première tentative de golf de code.

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 octets

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

Essayez-le en ligne ici .

Perl, 193 197 187 180 166 163B

Pénalité de 1 octet pour le commutateur de ligne de commande -n. Courir avec 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'

Avec des espaces:

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

Version non-golfée

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

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

Ma première tentative de code golf. Je pense que cela fonctionne mais ce n'est pas subtil.

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"

Enfin lié avec python 2!

Charbon de bois , 28 24 22 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

↙O

Imprimez le haut Oet laissez le curseur un espace en bas à gauche.

Ｆ↔θ/¶\¶ \¶

Imprimer les chaînes /, \et  \et répétez l' opération pour la valeur de nombre absolu de l'entrée.

↗

Revenez sur le dernier \.

‖Ｂ

Réfléchissez pour créer le côté droit de l'hélice. Je le fais ici car sinon, l' ↗analyse ne serait pas analysée sans ambiguïté.

O

Écraser le dernier \avec un O.

¿›Ｎ⁰⟲Ｔ

Si l'entrée était positive, faites pivoter la toile.

Toile , 33 32 30 octets

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

Essayez-le ici!

Explication:

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

Pas du tout la réponse la plus courte, mais la première en C ++ à ce jour :)

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

La voici en C ++ Shell avec des espaces à tester

perl 156

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

Assez simple tentative, mon deuxième golf. Je pense que les nouvelles lignes comptent pour 1 octet, non?

Maintenant, essayez de trouver comment joindre tous ces ternaires. J'ai beaucoup de progrès à faire avec ceux de :'';partout.

C, 189 octets

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

Avec des espaces et des nouvelles lignes:

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

Quelques notes sur l'approche:

• Stocke le motif dans des tableaux de caractères. Ils sont décalés de 22 caractères pour éviter d’avoir besoin de plusieurs barres obliques inverses pour échapper aux caractères spéciaux.
• Utilise des motifs distincts pour horizontal, vertical et zéro. J'ai d'abord envisagé d'utiliser un seul motif et de le parcourir différemment pour les valeurs positives et négatives. Je ne l'ai pas mis en œuvre, mais j'avais l'impression que cela compliquerait un peu plus la logique. D'autant que la barre oblique centrale a la direction opposée pour les deux cas. Et comme les tables ne sont pas si grandes, cela semblait plus prometteur.
• Le code consiste principalement en des calculs d’index, avec une logique pour décider quand c’est fait et quand le modèle tourne en boucle. La plupart des calculs sont faits pour que cela fonctionne dans les deux cas avec leurs dimensions et règles de répétition différentes.

Perl, 184 octets

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

Je pensais que ça allait être beaucoup plus court! Il y a probablement des choses simples que je peux faire pour économiser quelques octets. Cela fait cinq ans que j'ai programmé sérieusement 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 octets

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

Essayez-le en ligne!