Schreiben Sie ein Programm, das eine Ganzzahl N über stdin oder die Befehlszeile aufnimmt.

Wenn N 0 ist, muss der einzelne Buchstabe Oauf stdout gedruckt werden.

Wenn N positiv ist , muss diese horizontale ASCII -Doppelhelix mit einer Breite von N Segmenten gedruckt werden.

Wenn N 1 ist, ist die Ausgabe:

 /\
O  O
 \/

Wenn N 2 ist, ist die Ausgabe:

 /\ /\
O  /  O
 \/ \/

Wenn N 3 ist, ist die Ausgabe:

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

Wenn N 4 ist, ist die Ausgabe:

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

Das Muster wird für größeres N genauso fortgesetzt. Beachten Sie, dass der Schrägstrich ( /) an allen Stellen verwendet werden muss, an denen sich die Helixen kreuzen, mit Ausnahme der OEnden.

Wenn N negativ ist , muss diese vertikale ASCII-Doppelhelix (gezeichnet - N Segmente hoch) gedruckt werden.

Wenn N -1 ist, ist die Ausgabe:

 O
/ \
\ /
 O

Wenn N -2 ist, ist die Ausgabe:

 O
/ \
\ /
 \
/ \
\ /
 O

Wenn N -3 ist, ist die Ausgabe:

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

Wenn N -4 ist, ist die Ausgabe:

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

Das Muster wird für kleinere N genauso fortgesetzt. Beachten Sie, dass Schrägstriche ( \) an allen Stellen verwendet werden müssen, an denen sich die Helixen kreuzen, mit Ausnahme der OEnden.

Einzelheiten

• Anstelle eines Programms können Sie eine Funktion schreiben, die N als Ganzzahl verwendet und das Ergebnis normal ausgibt oder als Zeichenfolge zurückgibt.
• Die Ausgabe für ein beliebiges N kann optional eine nachgestellte Newline enthalten.
• Jede Ausgabezeile für ein beliebiges N kann optional 4 oder weniger nachgestellte Leerzeichen enthalten.
• Es sollte niemals ein führendes Leerzeichen geben, das nicht Teil des angegebenen Musters ist.
• Der kürzeste Code in Bytes gewinnt.

CJam, 56 55 53 52 50 Bytes

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

Schau dir diese Größe an! Die Hauptschuldigen sind N = 0Sonderfall und die \statt /in der vertikalen Helix.

So funktioniert es:

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.

Der Code ist in drei Teile gegliedert:

• Der Teil X0>"\/"=" / \\\ / "+gibt entweder "/ / \\\ / "oder "\ / \\\ / "was entscheidend ist, da die Helix einfach aus alternierendem besteht "/ \"und "\ /"durch entweder " / "oder verbunden wird " \ ". Wenn Sie beispielsweise die Eingabe als "Eingabe" betrachten 2, lautet die letzte wiederholte Zeichenfolge "/ / \\ / / / \\ / "(ohne Escapezeichen). Dies hat offensichtlich /am Anfang einen zusätzlichen Platz und am Ende einen zusätzlichen Platz.
• Der zweite Teil besteht darin, die obige Zeichenfolge mit zusätzlichen Dingen zu korrigieren und zu teilen. Für eine Eingabe wäre 2die gewünschte letzte Zeichenfolge ohne Zeilenumbrüche " O / \\\ / / / \\\ / O", aber nach dem obigen Punkt haben wir nur "/ / \\\ / / / \\\ / ". Also entfernen wir das erste Zeichen, fügen ein Leerzeichen und 'Oam Anfang und 'Oam Ende ein weiteres hinzu . Dann haben wir es endlich in Teile von 3 geteilt
• Schließlich entscheiden wir, ob diese geteilte Zeichenfolge für eine vertikale Helix transponiert werden soll oder nicht. Verbinden Sie die Teile durch Zeilenumbrüche; Und wählen Sie zwischen diesem und einem einzelnen Zeichen 'O(für Eingabe 0 Fall)

Probieren Sie es hier online aus

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>

Bei Verwendung einer Zeichenfolge mit Vorlagen werden Zeilenumbrüche gezählt.

Mehr lesbar

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

Demonstration.

Erläuterung:

Der erste Abschnitt M[Jj"/\\"*hGdjP*G+*2dH*2\O_J)definiert eine Funktion g, die zwei Eingaben akzeptiert. Die erste Eingabe Gist die Anzahl der zu verwendenden Wiederholungen. Dies ist der absolute Wert der Eingabe. Die zweite Eingabe Hist das Zeichen, das in der Mitte der Spiralen platziert werden soll.

Die Funktion gibt eine Liste mit 3 Elementen zurück, die aus den 3 Zeilen der positiven Spirale und den 3 Spalten der negativen Spirale besteht.

Das erste Element ist definiert durch Jj"/\\"*hGd. *hGdist die Zeichenfolge von G+1Leerzeichen. Verbindet j"/\\"*hGddiese Zeichenfolge mit "/\"als Begrenzer. Das Jam Anfang speichert den resultierenden Wert für die zukünftige Verwendung.

Das zweite Element ist jP*G+*2dH*2\O. Wir beginnen mit +*2dH. Dies sind zwei Leerzeichen, gefolgt vom Eingabezeichen. Dann wiederholen wir diese Zeichenfolge Gmal mit *G. Dann entfernen wir das letzte Zeichen mit P. Zum Schluss umgeben wir diesen String mit zwei OZeichen, mit j ... *2\O.

Das dritte Element wird mit erzeugt _J. Dies ist einfach die Umkehrung der ersten Zeile.

Der letzte Abschnitt ?jb?gQ\/>Q0msdCg_Q\\Q\Owählt zwischen drei verschiedenen Möglichkeiten, positiv, negativ und null. Die erste Wenn-Dann-Bedingung Qist der Eingang. Die zweite Bedingung ist >Q0, ob der Eingang positiv ist.

Wenn QNull ist \O, wird das Zeichen Ogedruckt.

Wenn Qungleich Null ist, setzen wir das Ergebnis des zweiten Ternärs in Zeilenumbrüche und drucken es mit jb. Wenn Qpositiv ist, ist die Liste verbunden und gedruckt gQ\/, g(Q,"/").

Wenn Qnegativ, ist die Liste verbunden und gedruckt msdCg_Q\\. Wir beginnen mit g_Q\\, was ist g(-Q,"\"). Dann transponieren wir die Zeilen und Spalten mit C. msdwandelt die resultierenden Tupel von Zeichen in Zeichenfolgen um, die in Zeilenumbrüchen verbunden und gedruckt werden können.

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)

Erstellt die vertikale Doppelhelix aus einer Liste von Zeichenfolgen und transponiert sie, um die horizontale zu erhalten. Ich bin sicher, es könnte verbessert werden.

Java, 500 488 Bytes

Mein erster Versuch, und leider ist es 10 * länger als der aktuelle Anführer :(. Hat jemand irgendwelche Tipps (außer eine andere Sprache zu benutzen)?

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

Sie können es dann schreiben als:

*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

Angeregt durch Martins Kommentar , hier ist mein erster Versuch in etwa so:

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

Besser lesbar:

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

Ungolfed-Version:

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

Die Idee ist, die horizontale Anzeige aus der vertikalen Anzeige aufzubauen, indem die transponierte Zeichenmatrix gerendert wird.

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

Meine allererste Code-Golf-Einsendung, daher ist sie möglicherweise überhaupt nicht beeindruckend.

Verwendet nur den ternären Operator ... if ... else von Python, um die drei Szenarien zu trennen. Dadurch wird eine Zeichenfolge erstellt, bei der einige kleinere Zeichenfolgen eine bestimmte Anzahl zum Drucken wiederholt werden.

Julia, 229 Bytes

Oh man, das ist viel zu groß. Dies ist die mit Abstand längste Antwort. Ich könnte wahrscheinlich viel sparen, indem ich den String zurückgebe, anstatt ihn auszudrucken, oder indem ich den Matrixansatz ganz vermeide. Ich werde später damit experimentieren.

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)

Dadurch wird eine Lambda-Funktion erstellt, die eine einzelne Ganzzahl annimmt und die entsprechend formatierte Doppelhelix ausgibt. Um es zu nennen, geben Sie ihm einen Namen, z f=n->(...).

Ungolfed + Erklärung:

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

Ein paar Beispiele:

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

Probieren Sie es hier online aus

Perl, 91-97

Das Transponieren erwies sich am Ende als zu teuer.

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

Vorherige Lösung:

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

Teste mich .

Schema, 379 Bytes

Mein erster Versuch, Code Golf zu spielen und leider einer der längsten. :(

(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

Mein erster Ansatz mit besonders schönen Variablennamen:

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

_{Ich habe keine Ahnung, warum ich das tue. Muss eine Freizeitsache sein.}

Java, 317

Mein erster Code Golf Versuch.

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

Probieren Sie es hier online aus .

Perl, 193 197 187 180 166 163B

1 Byte Strafe für -n Kommandozeilenschalter. Laufen mit 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'

Mit Leerzeichen:

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

Ungolfed-Version

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

Mein erster Versuch, Code Golf zu spielen. Ich denke, es funktioniert, aber es ist nicht 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"

Endlich mit Python 2 verbunden!

Kohle , 28 24 22 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

↙O

Drucken Sie den oberen ORand aus und lassen Sie den Cursor eine Stelle nach unten und links.

Ｆ↔θ/¶\¶ \¶

Drucken Sie die Saiten /, \und ,  \und wiederholen Sie für den absoluten Zahlenwert des Eingangs.

↗

Gehe zurück über den letzten \.

‖Ｂ

Nachdenken, um die rechte Seite der Helix zu erzeugen. Ich mache das hier, weil die ↗sonst nicht eindeutig analysieren würden.

O

Überschreibe den letzten \mit einem O.

¿›Ｎ⁰⟲Ｔ

Wenn die Eingabe positiv war, drehen Sie die Zeichenfläche.

Canvas , 33 32 30 Bytes

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

Probieren Sie es hier aus!

Erläuterung:

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

Nicht die kürzeste Antwort, aber die erste in C ++ bisher :)

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

Hier ist es in C ++ Shell mit Leerzeichen zu testen

Perl 156

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

Ziemlich direkter Versuch, mein zweiter Golf. Ich denke, Zeilenumbrüche zählen als 1 Byte, oder?

Nun, um herauszufinden, wie man all diese Ternaries zusammenfügt. Ich habe viel Raum für Verbesserungen mit denen :'';überall.

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

Mit Leerzeichen und Zeilenumbrüchen:

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

Einige Anmerkungen zum Ansatz:

• Speichert das Muster in Zeichenfeldern. Sie werden um 22 Zeichen verschoben, um zu vermeiden, dass einige Backslashes erforderlich sind, um Sonderzeichen zu entkommen.
• Verwendet separate Muster für horizontal, vertikal und null. Ich habe anfangs überlegt, ein einziges Muster zu verwenden und es nur für positive und negative Werte unterschiedlich zu durchlaufen. Ich habe es nicht implementiert, aber ich hatte das Gefühl, dass es die Logik etwas komplizierter machen würde. Zumal der zentrale Schrägstrich für beide Fälle die entgegengesetzte Richtung hat. Und die Tische sind nicht so groß, deshalb schien dies vielversprechender.
• Der Code besteht hauptsächlich aus Indexberechnungen, wobei die Logik entscheidet, wann er ausgeführt wird und wann die Musterschleifen ablaufen. Ein Großteil der Mathematik ist vorhanden, sodass sie für beide Fälle mit ihren unterschiedlichen Dimensionen und Wiederholungsregeln funktioniert.

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;

Ich dachte, das würde viel kürzer werden! Es gibt wahrscheinlich einige einfache Dinge, die ich tun kann, um ein paar Bytes zu sparen. Es ist fünf Jahre her, seit ich ernsthaft in Perl programmiert habe!

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'

Probieren Sie es online!