通过stdin或命令行编写一个接受整数N的程序。

如果N为0，则O必须将单个字母打印到标准输出。

如果N为正，则必须打印此水平 ASCII艺术双螺旋（绘制N段宽）。

如果N为1，则输出为：

 /\
O  O
 \/

如果N为2，则输出为：

 /\ /\
O  /  O
 \/ \/

如果N为3，则输出为：

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

如果N为4，则输出为：

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

对于较大的N，该模式以完全相同的方式继续。请注意，/在螺旋线交叉的所有位置（O末端除外）都必须使用正斜杠（）。

如果N为负数，则必须打印此垂直 ASCII艺术双螺旋，将其绘制为-N段高。

如果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.

该代码分为三个部分：

• 该部分X0>"\/"=" / \\\ / "+给出"/ / \\\ / "或"\ / \\\ / "至关重要，因为螺旋仅由交替组成"/ \"，"\ /"并由" / "或连接" \ "。例如，如果您认为input是2，那么最后一个重复的字符串将是"/ / \\ / / / \\ / "（不转义）。显然这/在开始时有额外的空间，而在结尾处有额外的空间。
• 第二部分是用其他东西纠正上述字符串并拆分。对于输入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)定义了一个函数g，该函数接受两个输入。第一个输入G是要使用的重复次数。这是输入的绝对值。第二个输入H是放置在螺旋中心的字符。

该函数返回一个3元素列表，该列表由正螺旋的3行和负螺旋的3列组成。

第一个元素由定义Jj"/\\"*hGd。*hGd是一串G+1空格。以该分号j"/\\"*hGd连接该字符串"/\"。在J开头保存以备将来使用的结果值。

第二个元素是jP*G+*2dH*2\O。我们从开始+*2dH。这是两个空格，后跟输入字符。然后，用重复该字符串G时间*G。然后，我们使用删除其最后一个字符P。最后，我们用两个O字符将字符串括起来，即j ... *2\O。

第三个元素由生成_J。这只是第一行的相反。

后一部分?jb?gQ\/>Q0msdCg_Q\\Q\O在三种可能的可能性之间进行选择，正，负和零。第一个if-then条件Q为输入。第二个条件取决于>Q0输入是否为正。

如果Q为零，则打印\O字符O。

如果Q为非零值，我们将第二个三进制的结果加入换行符，并使用进行打印jb。如果Q是肯定的，加入和打印的清单gQ\/，g(Q,"/")。

如果Q为负，则加入并打印的列表为msdCg_Q\\。我们开始g_Q\\，这是g(-Q,"\")。然后，用换行C。msd将生成的字符元组转换为字符串，准备在换行符上连接并打印。

蟒蛇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 ...三元运算符将这三种情况分开。这样就产生了一个字符串，该字符串是通过重复一些较小的字符串一定次数来进行打印的。

朱莉娅，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)

这将创建一个lambda函数，该函数采用单个整数并打印格式正确的双螺旋。要给它起个名字，例如f=n->(...)。

取消+说明：

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字节

我第一次尝试打高尔夫球，但不幸的是，这是最长的尝试之一。:(

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

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

_{我不知道为什么要这么做。一定是娱乐性的东西。}

爪哇省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;

JAVA 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

打印顶部O，并使光标向左和向左留一格。

Ｆ↔θ/¶\¶ \¶

打印字符串/，\然后 \重复输入的绝对数字值。

↗

返回上一个\。

‖Ｂ

反射以创建螺旋线的右侧。我在这里这样做是因为否则↗将不会明确解析。

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 ++ Shell中进行测试

Perl 156

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

相当直截了当的尝试，这是我的第二次高尔夫。我认为换行符算作1个字节吧？

现在要弄清楚如何将所有这些三元组结合在一起:'';。

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个字符，以避免需要一堆反斜杠来转义特殊字符。
• 对水平，垂直和零使用单独的模式。我最初考虑使用一种单一模式，只是以不同的方式遍历正负值。我没有实现它，但是我感觉到它会使逻辑变得更加复杂。特别是由于两种情况下中央斜线的方向相反。而且桌子没有那么大，所以这似乎更有希望。
• 该代码主要只是索引计算，并具有逻辑来确定何时完成以及模式何时循环。那里有很多数学运算，因此适用于具有不同尺寸和重复规则的两种情况。

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编程以来已经有五年了！

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'

在线尝试！