您将得到一个正整数N作为输入。您的任务是构建一个N各边长为的半锯齿形N。由于很难清楚地描述任务，因此以下是一些示例：

• N = 1：

  Ø
  

• N = 2：

  Ø
   面向对象
  

• N = 3：

  面向对象
   面向对象
    OOO
  

• N = 4：

  OOOOO
   面向对象
    面向对象
     OOOO
  

• N = 5：

  O
   OOO
    OOO
     OOO
      O
  

• N = 6：

  OO
   OOO
    OOO
     OOO
      OOO
       喔喔喔喔
  

• N = 7：

  喔喔喔喔
   OOOO
    OOOO
     OOOO
      OOOO
       OOOO
        OOOOOOOOOOOOOO
  

• 一个更大的测试用例 N = 9

如您所见，Semi-Zigzag由交替的对角线和水平线组成，并且始终从左上角到右下角对角线开始。请注意，水平线上的字符由空格分隔。

规则

• 您可以选择任何非空白字符来代替O，甚至可能不一致。

• 您可以将结果作为String或String列表输出/返回，每个String代表一行。

• 您可能会有尾随或换行符。

• 默认漏洞适用。

• 您可以采用任何标准均值进行输入并提供输出。

• 如果可能，请在您的提交中添加测试链接。我会用任何能说明高尔夫运动并有解释的答案作答。

• 这是代码高尔夫球，因此每种语言中以字节为单位的最短代码胜出！

木炭，24字节

ＦＮ«↶§7117ι×⁺#× ﹪ι²⁻Ｉθ¹»#

在线尝试！

-5感谢Neil。

AST：

Program
├Ｆ: For
│├Ｎ: Input number
│└Program
│ ├↶: Pivot Left
│ │└§: At index
│ │ ├'7117': String '7117'
│ │ └ι: Identifier ι
│ └Print
│  └×: Product
│   ├⁺: Sum
│   │├'#': String '#'
│   │└×: Product
│   │ ├' ': String ' '
│   │ └﹪: Modulo
│   │  ├ι: Identifier ι
│   │  └2: Number 2
│   └⁻: Difference
│    ├Ｉ: Cast
│    │└θ: Identifier θ
│    └1: Number 1
└Print
 └'#': String '#'

Python 2中，157个 153字节

n=input()
o,s=q='O '
def p(k,t=q*n+s*(4*n-6)):print(t*n)[k*~-n:][:n*3/2*~-n+1]
p(2)
for i in range(n-2):p(0,i*s+s+o+s*(4*n-7-2*i)+o+s*(2*n+i-2))
n>1>p(5)

在线尝试！

• n*3/2*~-n+1 是每行的宽度：⌊3n/2⌋·（n-1）+ 1个字符。
• 该字符串q*n+s*(4*n-6)代表顶部和底部行。如果我们重复并切片，[2*(n-1):]我们将获得第一行；如果我们切片，[5*(n-1):]我们将得到最下面一行。因此的定义p，并调用p(2)和p(5)。但是由于无论如何我们都需要对所有其他行进行重复和行长切片，因此我们p在循环中重复使用。
• 的i*s+s+o+…仅仅是中间行枯燥的表达。
• n>1>p(5)如果会短路n≯1，导致p(5)无法评估。因此，它是的简写if n>1:p(5)。

Mathematica，126 125 121 112 104 89 86字节

(m=" "&~Array~{#,#^2-#+1};Do[m[[1[i,#,-i][[j~Mod~4]],j#-#+i+1-j]]="X",{j,#},{i,#}];m)&

• #是匿名函数的输入数字（以final结尾&）。
• m=" "&~Array~{#,#^2-#+1};通过#,#^2-#+1使用常量匿名函数“输出空间”的输出填充给定尺寸的数组，来形成大小合适的空间字符矩阵" "&。
• Do[foo,{j,#},{i,#}]是一对嵌套的do循环，其中j范围从1到#，内部i范围从1到#。
• m[[1[i,#,-i][[j~Mod~4]],j#-#+i+1-j]]="X"X根据j和将矩阵的相应部分设置为字符i。在-i使用负索引从保存字节#-i+1。（我忘了写Mod[j,4]的j~Mod~4这个代码的原始版本。）Jenny_mathy指出，我们可以直接使用模块化残留索引到列表（而不是使用Switch）保存9个字节，JungHwan民指出，我们没”无需使用，ReplacePart因为我们可以设置数组的一部分，并且1[i,#,-i][[j~Mod~4]]使用奇数行为和通用性[[foo]]来保存字节{1,i,#,-i}[[j~Mod~4+1]]
• 由于meta确定字符列表是字符串（正如JungHwan Min指出的那样），我们不需要在字符矩阵的行上映射任何函数，因为它已经是“字符串”列表。

您可以在Wolfram Cloud沙箱中进行测试，方法是粘贴以下代码，然后按Shift + Enter或numpad Enter：

(m=" "&~Array~{#,#^2-#+1};Do[m[[1[i,#,-i][[j~Mod~4]],j#-#+i+1-j]]="X",{j,#},{i,#}];m)&@9//MatrixForm

C ++，321234字节

-87字节感谢Zacharý

#include<vector>
#include<string>
auto z(int n){std::vector<std::string>l;l.resize(n,std::string(n*n+n/2*(n-1),32));l[0][0]=79;int i=0,j,o=0;for(;i<n;++i)for(j=1;j<n;++j)l[i%4?i%4-1?i%4-2?0:n-j-1:n-1:j][i*n+j-i+(o+=i%2)]=79;return l;}

返回字符串向量

Mathematica，179个字节

Rotate[(c=Column)@(t=Table)[{c@(a=Array)[" "~t~#<>(v="o")&,z,0],c@t[t[" ",z-1]<>v,z-1],c@a[t[" ",z-2-#]<>v&,z-1,0],c@t[v,z-Boole[!#~Mod~4<1]-1]}[[i~Mod~4+1]],{i,0,(z=#)-1}],Pi/2]&

编辑@JungHwanMin

05AB1E，21 20 19字节

码

使用新的画布模式：

Fx<)Nè'ONÉúR3212NèΛ

使用05AB1E编码。在线尝试！

说明：

F                      # For N in range(0, input)
 x<)                   #   Push the array [input, 2 × input - 1]
    Nè                 #   Retrieve the Nth element
      'ONÉúR           #   Push "O" if N is odd, else "O "
            3212Nè     #   Retrieve the Nth element of 3212
                  Λ    #   Write to canvas

对于输入6，这将为画布提供以下参数（顺序相同）：

[<num>, <fill>, <patt>]
[6,     'O',     3]
[11,    'O ',    2]
[6,     'O',     1]
[11,    'O ',    2]
[6,     'O',     3]
[11,    'O ',    2]

为了解释画布的功能，我们从上面的列表中选择第一组参数。

数字6确定将写入画布的字符串的长度。填充符用于在画布上书写，本例中为O。它周期性地通过填充字符串。字符串的方向由最后一个参数（方向）确定。方向是：

7  0  1
 \ | /
6- X -2
 / | \
5  4  3

这意味着3号机将方向设定为东南方向，也可以在线尝试。

SOGL V0.12，36 个字节

╝.H∫2\?.╝}F2%?№@.┌Ο};1w⁄Hh1ž}.4%1>?№

在这里尝试！

基本思想是为输入范围的每个数字选择添加对角线或水平虚线部分，在这种情况下，它将旋转数组以更容易添加。说明：

╝                                     get a diagonal from the bottom-left corner with the length of the input - the starting canvas
 .H∫                        }         for each number in the range [1,inp-1] do, pushing counter
    2\?  }                              if it divides by 2, then
       .╝                                 create another diagonal of the input
          F2%                           push counter % 2
             ?     }                    if that [is not 0]
              №                           reverse the current canvas upside down
               @.┌Ο                       get an alternation of spaces and dashes with the dash amount of the input length
                    ;                   get the canvas on top of the stack
                     1w⁄                get its 1st element length
                        H               decrease it
                         h              swap the bottom 2 items - the canvas is now at the bottom and the current addition ontop
                          1             push 1
                           ž            at 1-indexed coordinates [canvasWidth-1, 1] in the canvas insert the current part made by the Ifs
                             .4%1>?   if input%4 > 1
                                   №    reverse the array vertically

如果不允许输入1，则 ο.∫2%?.╝}F2\?№@.┌Ο};1w⁄Hh1ž}.4%1>?№也可以工作。如果允许随机数浮动也.∫2%?.╝}F2\?№@.┌Ο};1w⁄Hh1ž}.4%1>?№将工作。如果我不懒惰并实现‼，}F2%?可以用‼-4个字节替换

Mathematica， 106 87字节

SparseArray[j=i=1;k=#-1;Array[{j+=Im@i;k∣#&&(i*=I);j,#+1}->"o"&,l=k#+1,0],{#,l}," "]&

返回一个 SparseArrayString s对象。要可视化输出，可以附加Grid@。为case抛出错误1，但是可以忽略。

说明

j=i=1

设置i和j为1。

k=#-1

组 k为输入-1。

l=k#+1

组 l于k*input + 1

Array[ ..., l= ...,0]

迭代l时间，从开始0，1每次增加...

j+=Im@i

将虚部添加i到j...

k∣#&&(i*=I)

如果当前迭代可被整除k，则乘以i虚数单位...

{... j,#+1}->"o"

创建一个Rule对象，将位置的元素更改{j, current iteration + 1}为"o"

SparseArray[ ...,{#,l}," "]

创建一个 SparseArray使用所生成的对象Rule的对象，与尺寸{input, l}，使用" "作为空白。

在Wolfram Sandbox上尝试！

Python 3中，228个226 224 215 197 195字节

-11个字节感谢@Mr。Xcoder

-2个字节感谢@Mr。Xcoder

def f(n,s=range):
 x=y=t=c=0;z=[]
 for i in s(n*n-n+2):c+=i%(n-(2<=n))<1;z+=[[x,y]];t=max(t,x);x+=2-c%2;y+=[-1,1][c%4<3]*(c%2)
 return'\n'.join(''.join(' O'[[k,j]in z]for k in s(t))for j in s(n))

在线尝试！

解释和不那么复杂的代码：

def f(n):
 x=y=t=c=0;z=[]                       #initialize everything
 for i in range(n*n-n+2):             #loop n*n-n+2 times which is the numberr of 'o's expected
    c+=i%[~-n,n]<n-1                  #if one cycle has been completed, increase c by 1, if n>1.                                            
    z+=[[x,y]]                        #add [x,y] to z(record the positions of 'o')
    t=max(t,x)                        #trap maximum value of x-coordinate(to be used later while calculatng whole string)
    r=[[2,0],[1,1],[2,0],[1,-1]][c%4] #r gives direction for x and y to move, adjust it as per c i.e. cycles
    x+=r[0];y+=r[1]                   #yield newer values of x and y 
 return '\n'.join(''.join(' o'[[k,j]in z]for k in range(t))for j in range(n)) #place space or 'o' accordingly as per the recorded posititons in z

Haskell，197个字节

a n c=take(2*n)$cycle$c:" "
r i n x y=take(div(3*n)2*(n-1)+1)$(' '<$[1..i])++(cycle$"O "++(a(2*n-i-3)y)++"O "++(a(n+i-2)x))
z n=take n$(r 0 n 'O' ' '):[r i n ' ' ' '|i<-[1..n-2]]++[r(n-1)n ' ' 'O']

在线尝试！

感谢@Lynn：修复了O之字形水平段上s 之间的空格，但是它花费了很多字节！

一些解释：

• r是输出的一行：它具有0 y y y y y 0 x x x 0 y ...格式，数量x和y取决于行和初始n
• 对于第一行，x='0'以及y=' '
• 对于中间的行，x=' '以及y=' '
• 对于底部行，x=' '和y='0'
• take(div(3*n)2*(n-1)+1) 在正确的位置剪切无限行
• 每个输出都有一个顶行和一个底行，但当n=1：take n处理这种情况时除外。

Python 2中，155个 151 146 137字节

m=input()
n=m-1
r=range(n+2)
for L in zip(*[' '*i+'O'+n*' 'for i in(r+[n,m]*~-n+r[-2::-1]+([m,0]*n)[:-1])*m][:1+3*m/2*n]):print''.join(L)

在线尝试！