Napisz program, który przyjmuje liczbę całkowitą N za pomocą stdin lub wiersza poleceń.

Jeśli N wynosi 0, pojedyncza litera Omusi być wydrukowana na stdout.

Jeśli N jest dodatnie , ta pozioma podwójna helisa sztuki ASCII , narysowana na szerokość N segmentów, musi zostać wydrukowana.

Jeśli N wynosi 1, wynikiem jest:

 /\
O  O
 \/

Jeśli N wynosi 2, wynikiem jest:

 /\ /\
O  /  O
 \/ \/

Jeśli N wynosi 3, wynikiem jest:

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

Jeśli N wynosi 4, wynikiem jest:

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

Wzór jest kontynuowany dokładnie w ten sam sposób dla większych N. Zauważ, że ukośnik do przodu ( /) musi być stosowany we wszystkich miejscach, w których przecinają się helisy, z wyjątkiem Okońców.

Jeśli N jest ujemne , ta pionowa podwójna helisa sztuki ASCII, narysowana -N segmenty wysokości, musi zostać wydrukowana.

Jeśli N wynosi -1, wynikiem jest:

 O
/ \
\ /
 O

Jeśli N wynosi -2, wynikiem jest:

 O
/ \
\ /
 \
/ \
\ /
 O

Jeśli N wynosi -3, wynikiem jest:

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

Jeśli N wynosi -4, wynikiem jest:

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

Wzór jest kontynuowany dokładnie w ten sam sposób dla mniejszych N. Zauważ, że \odwrotne ukośniki ( ) muszą być stosowane we wszystkich miejscach, w których helisy się krzyżują, z wyjątkiem Okońców.

Detale

• Zamiast programu możesz napisać funkcję, która przyjmuje N jako liczbę całkowitą i drukuje wynik normalnie lub zwraca jako ciąg znaków.
• Dane wyjściowe dla dowolnego N mogą opcjonalnie zawierać końcowy znak nowej linii.
• Dowolny wiersz wyniku dla dowolnego N może opcjonalnie zawierać 4 lub mniej końcowych spacji.
• Nigdy nie powinno być żadnej wiodącej przestrzeni, która nie jest częścią określonego wzorca.
• Najkrótszy kod w bajtach wygrywa.

CJam, 56 55 53 52 50 bajtów

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

Spójrz na ten rozmiar! Głównymi winowajcami są N = 0przypadki szczególne i \zamiast /w pionowej helisie.

Oto jak to działa:

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.

Kod podzielony jest na trzy części:

• Część X0>"\/"=" / \\\ / "+daje jedną "/ / \\\ / "lub "\ / \\\ / "co jest kluczowe, ponieważ spirala jest po prostu złożona z naprzemiennie "/ \"i "\ /"połączona przez jedną " / "lub " \ ". Na przykład, jeśli weźmiesz pod uwagę dane wejściowe 2, to twój ostatni powtórzony ciąg będzie "/ / \\ / / / \\ / "(bez ucieczki). To oczywiście ma dodatkowe /na początku i dodatkowe miejsce na końcu.
• Druga część to poprawienie powyższego ciągu o dodatkowe rzeczy i podział. Dla danych wejściowych 2pożądany ciąg końcowy bez znaków nowej linii byłby " O / \\\ / / / \\\ / O", ale po powyższym punkcie mamy tylko "/ / \\\ / / / \\\ / ". Usuwamy więc pierwszą postać, dodajemy spację i 'Ona początku, a drugą 'Ona końcu. Następnie podzieliliśmy go na części 3
• Wreszcie decydujemy, czy transponować ten podzielony ciąg dla helisy pionowej, czy nie; Dołącz do części przez nowe linie; I wybierz pomiędzy tym a pojedynczym znakiem 'O(dla wielkości 0)

Wypróbuj online tutaj

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>

Przy użyciu ciągów szablonowych liczą się znaki nowej linii.

Bardziej czytelny

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 bajty

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

Demonstracja.

Wyjaśnienie:

Pierwsza sekcja M[Jj"/\\"*hGdjP*G+*2dH*2\O_J)definiuje funkcję g, która pobiera dwa dane wejściowe. Pierwszym wejściem Gjest liczba powtórzeń do użycia. Jest to bezwzględna wartość wejściowa. Drugim wejściem Hjest znak, który należy umieścić na środku spirali.

Funkcja zwraca listę 3 elementów, która składa się z 3 linii spirali dodatniej i 3 kolumn spirali ujemnej.

Pierwszy element jest zdefiniowany przez Jj"/\\"*hGd. *hGdto ciąg G+1spacji. j"/\\"*hGdłączy ten ciąg z "/\"delimerem. JNa początku oszczędza uzyskanej wartości do wykorzystania w przyszłości.

Drugi element to jP*G+*2dH*2\O. Zaczynamy od +*2dH. Są to dwie spacje, po których następuje znak wejściowy. Następnie powtarzamy ten ciąg znaków za Gpomocą *G. Następnie usuwamy jego końcową postać za pomocą P. Na koniec otaczamy ten ciąg dwoma Oznakami, przy pomocy j ... *2\O.

Trzeci element jest generowany za pomocą _J. Jest to po prostu odwrotność pierwszej linii.

Druga sekcja ?jb?gQ\/>Q0msdCg_Q\\Q\Owybiera pomiędzy trzema różnymi możliwościami, dodatnią, ujemną i zerową. Pierwszy warunek „jeśli-to” włączony Q, wejście. Drugi warunek dotyczy >Q0tego, czy sygnał wejściowy jest dodatni.

Jeśli Qwynosi zero, drukowany jest \Oznak O.

Jeśli Qjest niezerowy, łączymy wynik drugiej trójki na znakach nowej linii i drukujemy za pomocą jb. Jeśli Qjest pozytywna, lista połączone i wydrukowane to gQ\/, g(Q,"/").

Jeśli Qjest ujemna, lista jest dołączana i drukowana msdCg_Q\\. Zaczynamy od g_Q\\, czyli g(-Q,"\"). Następnie transponujemy wiersze i kolumny za pomocą C. msdzamienia powstałe krotki znaków w ciągi znaków, gotowe do połączenia na nowej linii i wydrukowania.

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)

Tworzy pionową podwójną helisę z listy ciągów i transponuje ją, aby uzyskać poziomą. Jestem pewien, że można to poprawić.

Java, 500 488 bajtów

Moja pierwsza próba i niestety jest 10 * dłużej niż obecny lider :(. Czy ktoś ma jakieś wskazówki (inne niż użycie innego języka)?

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 bajtów

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

Następnie możesz napisać jako:

*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 bajtów

Zachęcony komentarzem Martina , oto moja pierwsza próba czegoś takiego:

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

Bardziej czytelnie:

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 bajtów

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

Wersja bez golfa:

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

Chodzi o to, aby zbudować wyświetlacz poziomy z wyświetlacza pionowego, renderując transponowaną matrycę znaków.

Python 3, 118 bajtów

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

Moje pierwsze zgłoszenie do gry w golfa, więc może nie być wcale imponujące.

Po prostu używa Python's ... if ... else ... trójskładnikowy operator do rozdzielenia trzech scenariuszy. To daje ciąg złożony z powtarzania niektórych mniejszych ciągów określoną liczbę razy do wydrukowania.

Julia, 229 bajtów

O rany, to jest o wiele za duże. To najdłuższa jak dotąd odpowiedź z dużym marginesem. Prawdopodobnie mógłbym dużo zaoszczędzić, zwracając ciąg zamiast go drukować lub całkowicie unikając matrycy. Eksperymentuję z tym później.

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)

Tworzy to funkcję lambda, która przyjmuje pojedynczą liczbę całkowitą i drukuje odpowiednio sformatowaną podwójną helisę. Aby to nazwać, nadaj mu nazwę, np f=n->(...).

Niegolfowane + wyjaśnienie:

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

Kilka przykładów:

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

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

Python 3, 135 bajtów

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

Wypróbuj online tutaj

Perl, 91 97

Ostatecznie transpozycja okazała się zbyt droga.

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

Poprzednie rozwiązanie:

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

Przetestuj mnie .

Schemat, 379 bajtów

Moja pierwsza próba golfa kodowego i niestety jedna z najdłuższych. :(

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

Niesklasyfikowane:

(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

Moje pierwsze podejście ze szczególnie ładnymi nazwami zmiennych:

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

_{Nie mam pojęcia, dlaczego to robię. To musi być coś rekreacyjnego.}

Java, 317

Moja pierwsza próba golfowego kodu.

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 bajtów

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

Wypróbuj online tutaj .

Perl, 193 197 187 180 166 163B

1 bajt kary za przełącznik -n wiersza poleceń. Uruchom z 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'

Z białymi znakami:

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

Wersja bez golfa

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

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

Moja pierwsza próba golfa kodowego. Myślę, że to działa, ale nie jest subtelne.

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"

Nareszcie związany z python 2!

Węgiel drzewny , 28 24 22 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

↙O

Wydrukuj górę Oi pozostaw kursor o jedno miejsce w dół i w lewo.

Ｆ↔θ/¶\¶ \¶

Drukuj łańcuchy /, \a  \i powtórzyć dla absolutnej wartości numer wejścia.

↗

Wróć do ostatniego \.

‖Ｂ

Zastanów się, aby utworzyć prawą stronę helisy. Robię to tutaj, ponieważ w przeciwnym ↗razie nie parsowałyby się jednoznacznie.

O

Nadpisać ostatnią \ze związkiem O.

¿›Ｎ⁰⟲Ｔ

Jeśli dane wejściowe były dodatnie, obróć płótno.

Płótno , 33 32 30 bajtów

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

Wypróbuj tutaj!

Wyjaśnienie:

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

Wcale nie najkrótsza odpowiedź, ale jak dotąd pierwsza w C ++ :)

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

Tutaj jest w C ++ Shell z białymi znakami do przetestowania

perl 156

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

Całkiem prosta próba, mój drugi golf. Myślę, że nowe linie liczą się jako 1 bajt, prawda?

Teraz wymyślę, jak połączyć wszystkie te trójskładniki razem. Mam dużo miejsca na ulepszenia z tymi :'';wszędzie.

C, 189 bajtów

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

Z białymi znakami i znakami nowej linii:

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

Kilka uwag na temat tego podejścia:

• Przechowuje wzór w tablicach znaków. Są przesunięte o 22 znaki, aby uniknąć konieczności stosowania ukośników odwrotnych, aby uciec od znaków specjalnych.
• Używa oddzielnych wzorów dla poziomu, pionu i zera. Początkowo zastanawiałem się nad użyciem jednego wzorca i po prostu przeszedłem go inaczej dla wartości dodatnich i ujemnych. Nie wdrożyłem go, ale miałem wrażenie, że skomplikowałoby to logikę. Zwłaszcza, że ​​środkowy ukośnik ma przeciwny kierunek dla obu przypadków. A stoły nie są tak duże, więc wydawało się to bardziej obiecujące.
• Kod to głównie tylko obliczenia indeksu, z logiką decydującą o tym, kiedy to się zakończy, a kiedy wzorzec zapętli się. Duża część matematyki istnieje, więc działa ona w obu przypadkach z ich różnymi wymiarami i zasadami powtarzania.

Perl, 184 bajty

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

Myślałem, że to będzie o wiele krótsze! Prawdopodobnie jest kilka prostych rzeczy, które mogę zrobić, aby zaoszczędzić kilka bajtów. Minęło pięć lat, odkąd poważnie programowałem w Perlu!

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 bajtów

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

Wypróbuj online!