stdinまたはコマンドラインを介して整数Nを取り込むプログラムを作成します。

Nが0の場合、1文字Oを標準出力に印刷する必要があります。

Nが正の場合、Nセグメント幅で描かれたこの水平 ASCIIアート二重らせんを印刷する必要があります。

Nが1の場合、出力は次のとおりです。

 /\
O  O
 \/

Nが2の場合、出力は次のとおりです。

 /\ /\
O  /  O
 \/ \/

Nが3の場合、出力は次のとおりです。

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

Nが4の場合、出力は次のとおりです。

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

パターンは、Nが大きい場合もまったく同じように続きます。/らせんが交差するすべての場所（O両端を除く）でスラッシュ（）を使用する必要があることに注意してください。

Nが負の場合、-Nセグメントの高さで描かれたこの垂直 ASCIIアート二重らせんを印刷する必要があります。

Nが-1の場合、出力は次のとおりです。

 O
/ \
\ /
 O

Nが-2の場合、出力は次のとおりです。

 O
/ \
\ /
 \
/ \
\ /
 O

Nが-3の場合、出力は次のとおりです。

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

Nが-4の場合、出力は次のとおりです。

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

パターンは、Nが小さい場合もまったく同じように続きます。\らせんが交差するすべての場所（O両端を除く）でバックスラッシュ（）を使用する必要があることに注意してください。

詳細

• プログラムの代わりに、整数としてNを取り、結果を通常どおりに出力するか、文字列として返す関数を作成できます。
• Nの出力には、オプションで末尾の改行を含めることができます。
• 任意のNの出力行には、オプションで4つ以下の末尾スペースを含めることができます。
• 指定されたパターンの一部ではない先行スペースが存在することはありません。
• バイト単位の最短コードが優先されます。

CJam、56 55 53 52 50バイト

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

そのサイズを見てください！主な原因はN = 0特別な場合であり、垂直らせんの\代わりです/。

仕組みは次のとおりです。

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.

コードは3つの部分に分かれています。

• 部分は、X0>"\/"=" / \\\ / "+いずれかの与え"/ / \\\ / "又は"\ / \\\ / "ヘリックスを単に交互に構成されているように重要である"/ \"と"\ /"のいずれかにより接合され" / "、または" \ "。たとえば、入力をと見なした場合2、最後に繰り返される文字列は"/ / \\ / / / \\ / "（エスケープせずに）なります。これは明らかに/最初に余分なスペースがあり、最後に余分なスペースがあります。
• 2番目の部分は、上記の文字列を追加のもので修正し、分割することです。inputの2場合、改行なしの目的の最終文字列はになります" O / \\\ / / / \\\ / O"が、上記のポイントの後はのみになります"/ / \\\ / / / \\\ / "。したがって、最初の文字を削除し、スペースを追加'Oし、先頭と'O末尾にスペースを追加します。その後、最終的に3つの部分に分割しました
• 最後に、この分割文字列を垂直らせんに転置するかどうかを決定します。改行でパーツを結合します。そして、これと単一の文字から選択します'O（入力0の場合）

こちらからオンラインでお試しください

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>

テンプレート化された文字列を使用すると、改行がカウントされます。

より読みやすい

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バイト

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

デモンストレーション。

説明：

最初のセクション、M[Jj"/\\"*hGdjP*G+*2dH*2\O_J)は、g2つの入力を受け取る関数を定義します。最初の入力はG、使用する繰り返しの数です。これは、入力の絶対値です。2番目の入力Hは、スパイラルの中心に配置する文字です。

この関数は、正のスパイラルの3行と負のスパイラルの3列で構成される3要素のリストを返します。

最初の要素はで定義されJj"/\\"*hGdます。スペース*hGdの文字列G+1です。j"/\\"*hGdその文字列を"/\"区切り文字として結合します。J冒頭には、将来の使用のためにその値が保存されます。

2番目の要素はjP*G+*2dH*2\Oです。で始まり+*2dHます。これは、2つのスペースとそれに続く入力文字です。その後、我々は、その文字列の繰り返しGで時間を*G。次に、で最後の文字を削除しPます。最後に、この文字列を2つのO文字で囲みますj ... *2\O。

3番目の要素はで生成され_Jます。これは単に最初の行の逆です。

後者のセクションでは?jb?gQ\/>Q0msdCg_Q\\Q\O、正、負、ゼロの3つの異なる可能性から選択します。最初のif-then条件Q、入力。2番目の条件は>Q0、入力が正であるかどうかです。

Qがゼロの場合\O、文字Oが出力されます。

Qがゼロ以外の場合、2番目の3項の結果を改行で結合し、で印刷しjbます。場合はQ正であり、参加し、印刷されたリストがありますgQ\/、g(Q,"/")。

場合はQ負であり、参加し、印刷されたリストですmsdCg_Q\\。私たちは、で始まるg_Q\\です、g(-Q,"\")。次に、で行と列を転置しますC。msd結果の文字のタプルを文字列に変換し、改行で結合して印刷できるようにします。

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)

文字列のリストから垂直の二重らせんを作成し、それを転置して水平のものを取得します。改善できると確信しています。

Java、500 488バイト

私の最初の試み、そして残念なことに、現在のリーダーよりも10倍長いです:(

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バイト

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

その後、次のように記述できます。

*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バイト

マーティンのコメントに拍車をかけ、これが私の最初の試みです。

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

より読みやすい：

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バイト

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

ゴルフされていないバージョン：

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

アイデアは、文字の転置行列をレンダリングすることにより、垂直ディスプレイから水平ディスプレイを構築することです。

Python 3、118バイト

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

私が初めてゴルフのコードを提出したので、まったく印象的ではないかもしれません。

Pythonの... if ... else ...三項演算子を使用して、3つのシナリオを分離します。これにより、いくつかの小さな文字列を一定の回数繰り返して作られた文字列が印刷されます。

ジュリア、229バイト

男ああ、これは、方法です方法が大きすぎます。これまでのところ、大きなマージンで最も長い答えです。文字列を印刷するのではなく返すことで、または行列アプローチを完全に回避することで、おそらく大幅に節約できます。後で実験します。

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)

これにより、単一の整数を受け取り、適切にフォーマットされた二重らせんを出力するラムダ関数が作成されます。呼び出すには、名前を付けf=n->(...)ます。

Ungolfed +説明：

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

いくつかの例：

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

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

Python 3、135バイト

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

こちらからオンラインでお試しください

Perl、91 97

転置は最終的に高すぎることが判明しました。

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

以前のソリューション：

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

私をテストしてください。

スキーム、379バイト

コードゴルフでの私の最初の試み、そして残念なことに、最も長いものの1つ。:(

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

未ゴルフ：

(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

私の最初のアプローチは、特に素晴らしい変数名を使用しています：

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

_{なぜこれをしているのか分かりません。娯楽的なものでなければなりません。}

Java、317

私の最初のコードゴルフの試み。

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バイト

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

こちらからオンラインでお試しください。

Perlの、193 197 187 180 166 163B

-nコマンドラインスイッチの1バイトのペナルティ。で実行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'

空白あり：

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

ゴルフされていないバージョン

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

ジャバ377 384 バイト

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

コードゴルフでの私の最初の試み。動作すると思いますが、微妙ではありません。

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"

最後にpython 2で結ばれました！

炭、28 24 22バイト

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

オンラインでお試しください！リンクは、コードの詳細バージョンです。説明：

↙O

topを印刷しO、カーソルを1つ下のスペースに残します。

Ｆ↔θ/¶\¶ \¶

文字列/、\および \を出力し、入力の絶対値に対して繰り返します。

↗

最後に戻り\ます。

‖Ｂ

反射してらせんの右側を作成します。そうしないと、↗明確に解析されないからです。

O

最後\をで上書きしOます。

¿›Ｎ⁰⟲Ｔ

入力が正の場合、キャンバスを回転させます。

キャンバス、33 32 30 バイト

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

ここで試してみてください！

説明：

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

最短の答えではありませんが、これまでの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");};}

ここでは、テストする空白を含むC ++シェルにあります

perl 156

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

かなり簡単な試み、私の2番目のゴルフ。改行は1バイトとしてカウントされると思いますか？

ここで、これらすべての3項を結合する方法を理解します:'';。

C、189バイト

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

空白と改行あり：

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

アプローチに関するいくつかの注意：

• パターンを文字配列に格納します。特殊文字をエスケープするためにバックスラッシュの束を必要としないように、それらは22文字シフトされます。
• 水平、垂直、およびゼロに個別のパターンを使用します。最初は単一のパターンを使用することを検討し、正と負の値について異なる方法で走査するだけでした。実装しませんでしたが、ロジックがかなり複雑になると感じました。特に、中央のスラッシュは2つのケースで反対方向になっているためです。そして、テーブルはそれほど大きくないので、これはより有望であるように思われました。
• コードは主に単なるインデックス計算であり、いつ実行され、いつパターンがループするかを決定するロジックがあります。数学の多くはそこにあるので、異なる次元と繰り返し規則で両方の場合に機能します。

Perl、184バイト

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

これはもっと短くなると思いました！おそらく、数バイトを節約するためにできる簡単なことがいくつかあります。Perlで真剣にプログラミングしてから5年が経ちました！

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バイト

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

オンラインでお試しください！