Tulis sebuah program yang mengambil bilangan bulat N melalui stdin atau baris perintah.

Jika N adalah 0, satu huruf Oharus dicetak ke stdout.

Jika N positif , heliks ganda seni ASCII horizontal ini , yang digambar dengan lebar N segmen, harus dicetak.

Jika N adalah 1, outputnya adalah:

 /\
O  O
 \/

Jika N adalah 2, outputnya adalah:

 /\ /\
O  /  O
 \/ \/

Jika N adalah 3, outputnya adalah:

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

Jika N adalah 4, outputnya adalah:

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

Pola berlanjut dengan cara yang sama persis untuk N. yang lebih besar. Perhatikan bahwa garis miring ( /) harus digunakan di semua tempat heliks bersilangan, kecuali untuk Oujungnya.

Jika N negatif , heliks ganda art ASCII vertikal ini , ditarik -N segmen tinggi, harus dicetak.

Jika N adalah -1, outputnya adalah:

 O
/ \
\ /
 O

Jika N adalah -2, outputnya adalah:

 O
/ \
\ /
 \
/ \
\ /
 O

Jika N adalah -3, outputnya adalah:

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

Jika N adalah -4, outputnya adalah:

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

Pola berlanjut dengan cara yang sama persis untuk N. yang lebih kecil. Perhatikan bahwa garis miring ( \) harus digunakan di semua tempat heliks bersilangan, kecuali untuk Oujungnya.

Detail

• Alih-alih sebuah program, Anda dapat menulis fungsi yang mengambil N sebagai integer dan mencetak hasilnya secara normal atau mengembalikannya sebagai string.
• Output untuk N apa pun secara opsional dapat memuat baris tambahan.
• Garis output apa pun untuk N apa pun dapat secara opsional mengandung 4 atau lebih sedikit ruang tambahan.
• Seharusnya tidak pernah ada ruang utama yang bukan bagian dari pola yang ditentukan.
• Kode terpendek dalam byte menang.

CJam, 56 55 53 52 50 byte

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

Lihatlah ukuran itu! Penyebab utama adalah N = 0kasus khusus dan \bukan /pada helix vertikal.

Inilah cara kerjanya:

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.

Kode ini dibagi menjadi tiga bagian:

• Bagian X0>"\/"=" / \\\ / "+memberikan salah satu "/ / \\\ / "atau "\ / \\\ / "yang penting karena heliks hanya terdiri dari alternatif "/ \"dan "\ /"bergabung dengan salah satu " / "atau " \ ". Misalnya, jika Anda menganggap input sebagai 2, maka string terakhir yang diulang Anda akan "/ / \\ / / / \\ / "(tanpa melarikan diri). Ini jelas memiliki ekstra /di awal dan ruang tambahan di akhir.
• Bagian kedua adalah memperbaiki string di atas dengan hal-hal tambahan dan membelah. Untuk input 2, string akhir yang diinginkan tanpa baris baru adalah " O / \\\ / / / \\\ / O", tetapi setelah titik di atas, kita hanya punya "/ / \\\ / / / \\\ / ". Jadi kami menghapus karakter pertama, tambahkan spasi dan 'Odi awal dan yang lain 'Odi akhir. Lalu kami akhirnya membaginya menjadi 3 bagian
• Akhirnya, kami memutuskan apakah akan memindahkan string perpecahan ini menjadi heliks vertikal atau tidak; Bergabunglah dengan bagian-bagian dengan baris baru; Dan pilih antara ini dan satu karakter 'O(untuk input 0 huruf)

Cobalah online di sini

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>

Menggunakan string templated, baris baru dihitung.

Lebih mudah dibaca

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

Demonstrasi.

Penjelasan:

Bagian pertama M[Jj"/\\"*hGdjP*G+*2dH*2\O_J),, mendefinisikan fungsi g,, yang mengambil dua input. Input pertama G,, adalah jumlah pengulangan yang digunakan. Ini adalah nilai absolut dari input. Input kedua H,, adalah karakter untuk ditempatkan di pusat spiral.

Fungsi mengembalikan daftar 3 elemen, yang terdiri dari 3 baris spiral positif, dan 3 kolom spiral negatif.

Elemen pertama didefinisikan oleh Jj"/\\"*hGd. *hGdadalah string G+1spasi. j"/\\"*hGdbergabung dengan string itu dengan "/\"sebagai delimeter. Di Jawal menyimpan nilai yang dihasilkan untuk digunakan di masa depan.

Elemen kedua adalah jP*G+*2dH*2\O. Kita mulai dengan +*2dH. Ini adalah dua spasi diikuti oleh karakter input. Kemudian, kami ulangi string Gkali dengan *G. Kemudian, kami menghapus karakter terakhirnya dengan P. Akhirnya, kami mengelilingi string ini dengan dua Okarakter, dengan j ... *2\O.

Elemen ketiga dihasilkan dengan _J. Ini hanyalah kebalikan dari baris pertama.

Bagian terakhir, ?jb?gQ\/>Q0msdCg_Q\\Q\Omemilih antara tiga kemungkinan yang berbeda, positif, negatif dan nol. Kondisi if-then pertama aktif Q, input. Kondisi kedua aktif >Q0, apakah inputnya positif.

Jika Qnol,, \Okarakter O, dicetak.

Jika Qbukan nol, kami bergabung dengan hasil terner kedua pada baris baru dan mencetaknya, dengan jb. Jika Qpositif, daftar bergabung dan dicetak gQ\/, g(Q,"/").

Jika Qnegatif, daftar yang bergabung dan dicetak adalah msdCg_Q\\. Kita mulai dengan g_Q\\, yaitu g(-Q,"\"). Lalu kami memindahkan baris dan kolom dengan C. msdmengubah tupel karakter yang dihasilkan menjadi string, siap untuk bergabung pada baris baru dan dicetak.

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)

Buat double helix vertikal dari daftar string dan transpos untuk mendapatkan yang horizontal. Saya yakin itu bisa diperbaiki.

Java, 500 488 byte

Coba pertama saya, dan sayangnya itu 10 * lebih lama dari pemimpin saat ini :(. Adakah yang punya tips (selain menggunakan bahasa yang berbeda)?

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

Anda kemudian dapat menuliskannya sebagai:

*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

Didorong oleh komentar Martin , inilah upaya pertama saya untuk sesuatu seperti ini:

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

Lebih mudah dibaca:

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

Versi tidak disatukan:

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

Idenya adalah untuk membangun tampilan horizontal dari tampilan vertikal dengan merender matriks karakter yang ditransposisikan.

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

Pengajuan kode golf pertama saya, jadi mungkin tidak mengesankan sama sekali.

Hanya menggunakan Python ... jika ... yang lain ... operator ternary untuk memisahkan tiga skenario. Itu memberikan string yang terbuat dari pengulangan beberapa string kecil beberapa kali untuk dicetak.

Julia, 229 byte

Oh man, ini adalah cara, cara terlalu besar. Ini adalah jawaban terpanjang sejauh ini dengan selisih yang besar. Saya mungkin bisa menghemat banyak dengan mengembalikan string daripada mencetaknya, atau dengan menghindari pendekatan matriks sama sekali. Saya akan bereksperimen dengan itu nanti.

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)

Ini menciptakan fungsi lambda yang mengambil integer tunggal dan mencetak heliks ganda yang diformat dengan tepat. Untuk menyebutnya, berikan nama, mis f=n->(...).

Penjelasan + tidak dikumpulkan:

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

Beberapa contoh:

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

Cobalah online di sini

Perl, 91 97

Transposing terbukti terlalu mahal pada akhirnya.

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

Solusi sebelumnya:

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

Ujilah aku .

Skema, 379 byte

Upaya pertama saya di golf kode dan, sayangnya, salah satu yang terpanjang. :(

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

Tidak Diunggulkan:

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

Jawa, 282

Pendekatan pertama saya, dengan nama variabel yang sangat bagus:

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

_{Saya tidak tahu mengapa saya melakukan ini. Pasti ada rekreasi.}

Jawa, 317

Upaya golf kode pertama saya.

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

Cobalah online di sini .

Perl, 193 197 187 180 166 163B

1 byte penalti untuk -n commandline switch. Jalankan dengan 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'

Dengan spasi putih:

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

Versi tidak disatukan

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

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

Upaya pertama saya di kode golf. Saya pikir itu berhasil tetapi tidak halus.

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"

Akhirnya diikat dengan python 2!

Arang , 28 24 22 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

↙O

Cetak bagian atas O, dan biarkan kursor satu spasi ke bawah dan ke kiri.

Ｆ↔θ/¶\¶ \¶

Cetak string /, \dan  \dan ulangi untuk nilai angka absolut dari input.

↗

Pindah kembali dari yang terakhir \.

‖Ｂ

Refleksikan untuk membuat sisi kanan helix. Saya melakukan ini di sini karena kalau tidak, ↗tidak akan parse jelas.

O

Timpa yang terakhir \dengan O.

¿›Ｎ⁰⟲Ｔ

Jika input positif maka putar kanvas.

Kanvas , 33 32 30 byte

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

Coba di sini!

Penjelasan:

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

Sama sekali tidak jawaban terpendek, tetapi yang pertama di C ++ sejauh ini :)

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

Ini dia di C ++ Shell dengan spasi untuk menguji

perl 156

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

Usaha ke depan yang cukup lurus, golf kedua saya. Saya pikir baris baru dihitung sebagai 1 byte, kan?

Sekarang untuk mencari tahu bagaimana cara menggabungkan semua terner itu bersama-sama .. Saya punya banyak ruang untuk perbaikan dengan yang ada di :'';mana - mana.

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

Dengan spasi putih dan baris baru:

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

Beberapa catatan tentang pendekatan:

• Menyimpan pola dalam susunan karakter. Mereka digeser oleh 22 karakter untuk menghindari membutuhkan banyak garis miring terbalik untuk keluar dari karakter khusus.
• Menggunakan pola terpisah untuk horizontal, vertikal, dan nol. Awalnya saya mempertimbangkan untuk menggunakan satu pola tunggal, dan hanya mengubahnya secara berbeda untuk nilai positif dan negatif. Saya tidak mengimplementasikannya, tetapi saya punya perasaan bahwa itu akan membuat logika sedikit lebih rumit. Terutama karena slash pusat memiliki arah yang berlawanan untuk kedua kasus. Dan meja tidak terlalu besar, jadi ini sepertinya lebih menjanjikan.
• Kode ini terutama hanya penghitungan indeks, dengan logika untuk memutuskan kapan hal itu dilakukan dan kapan pola loop. Sebagian besar matematika ada sehingga dapat bekerja untuk kedua kasus dengan dimensi dan aturan pengulangan yang berbeda.

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;

Saya pikir ini akan menjadi jauh lebih pendek! Mungkin ada beberapa hal sederhana yang bisa saya lakukan untuk menghemat beberapa byte. Sudah lima tahun sejak saya memprogram dengan serius di 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'

Cobalah online!