给定单个正整数作为输入，以以下形式返回收敛的之字形作为字符串列表，字符列表或换行符分隔的字符串：

#
 #
  #
   #
    #
   #
  #
 #
  #
   #
  #

您可以#用任何一致的非空白字符替换。允许在每行上尾随空白，并允许尾随新行。

之字形从列开始，1每行右移一列，直到到达列n（n输入在此处）。然后，它向左移动2，然后向右移动n-1，然后向左移动3，两个边界收敛，直到锯齿形在中间列（(n+1)/2）结束。

测试用例

上面的示例是的测试用例5。

以下是各个测试用例：

3
#
 #
  #
 #

7
#
 #
  #
   #
    #
     #
      #
     #
    #
   #
  #
 #
  #
   #
    #
     #
    #
   #
  #
   #
    #
   #

1

#

C（gcc），89个字节

f(n,a,b){puts("0");for(a=n;--a>n/2;)for(b=n-2*a;b<=2*a-n;)printf(" %*d\n",a-abs(b++),0);}

在线尝试！

通过将空格数的序列分析为（对于n = 7）来工作：

          0
1 2 3 4 5 6 5 4 3 2 1
    2 3 4 5 4 3 2
        3 4 3

对于n = 3：

  0
1 2 1

我们可以看到中间的数字（a在代码中）从[n-1，n / 2）开始。然后，第一个数字和中间数字之间的差为：

a  n  b  2a-n
-------------
6  7  5  5
5  7  3  3
4  7  1  1
2  3  1  1

因此，如果我们b经历了[-（2a-n），2a-n]，a-abs(b)将为我们提供所需的序列。这本质上就是代码的作用。

木炭，10 8字节

ＦＮ«↗ι‖»/

在线尝试！链接是详细版本的代码。编辑：由于@dzaima指出我不必使用#s ，因此节省了2个字节。

Python 2，78个字节

l=range(1,input())
print 8
for i in l:
 for i in l:print' '*i+'8'
 l=l[-2::-1]

在线尝试！

果冻，14字节

ṖṖṚ$ÐĿẎ0;⁶ẋp1Y

在线尝试！

完整程序。

用途1。

-1感谢乔纳森·艾伦。
-1感谢乔纳森·艾伦。

Haskell，72个字节

g[]=[]
g a=a++g(reverse$init a)
r="#":map(' ':)r
("#":).g.tail.(`take`r)

在线尝试！

我们定义一个无限列表，r它是#从左上角开始的s 的对角线。

然后，我们定义一个g首当其冲的功能。 g将获取一个列表并反复将其反转，并删除其第一个元素，直到列表为空，然后将每个操作的结果连接起来。

这里的主要功能是无点功能。此函数首先n从无限列表中r选取元素，然后将第一个元素切碎并应用g。最后，我们必须#在开头添加一个后缀，这是因为该问题的规格有些怪异，我不确定为什么第一个对角线总是比应有的长，但是，因此，我们必须添加aa #。

SOGL V0.12，19个字节

┘.»∫«I╝:±jk+jl0;±Iž

在这里尝试！

05AB1E，22字节

i8ë<LZFD¨R})˜0¸ìε8sú}»

在线尝试！

用途8。

05AB1E，6个字节

LN71SΛ

在线尝试！

     Λ     use the canvas function with

L          a range list [1 .. input] as lengths for each path 

 N         a "0" as character to be printed 
           (N is the index variable used by loops. If there was no loop yet, its
           default value is 0. By using N, I avoid an extra space between 0 and 71)

  71S      and the directions 7 and 1 (NW and NE), that alternate automatically until
           the range list is finished.

CJam，29个字节

ri,(;_,{_);W%}*]e_0\+Sf*8f+N*

在线尝试！

用途8。

Pyth，23个字节

8JStQKdVQjbm+*\ d8J=_PJ

在这里尝试。

JavaScript，127个字节

计算g要达到的目标（）。达到此目标后，转到下一个目标。还使用技巧来避免Math.round()通过将0.5每个不规则数字相加来使用。

f=n=>{c=0;for(i=0;i<n;i++){m=i/2;g=i%2==0?n-m:m+1.5;while(c!=g){c>g?c--:c++;console.log(' '.repeat(c-1)+'#'+' '.repeat(n-c))}}}

f=n=>{c=0;for(i=0;i<n;i++){m=i/2;g=i%2==0?n-m:m+1.5;while(c!=g){c>g?c--:c++;console.log(' '.repeat(c-1)+'#'+' '.repeat(n-c))}}}

f(5);

Haskell，74个字节

f[x]=[x]
f s=s++tail(f$reverse$tail s)
g n=f[(' '<$[2..x])++"#"|x<-[1..n]]

在线尝试！

怎么运行的：

    [(' '<$[2..x])++"#"|x<-[1..n]]     -- build the first diagonal, e.g. for n=3:
                                         -- ["#", " #", "  #"]
  f                                      -- call f, which is

f s = s ++                               -- the input list, followed by
           tail                          -- all but the first element of
                f                        -- a recursive call with
                  reverse                -- the reverse of
                          tail s         -- all but the first element of the input 
                                         -- list
f[x]=[x]                                 -- base case: stop if the input list a
                                         -- singleton list

每个递归调用都f将追加下一个对角线。

外壳，19个字节

mo`:'#R' ∫`Ṙ¢e1_1tṫ

在线尝试！

说明

这感觉有些笨拙。

mo`:'#R' ∫`Ṙ¢e1_1tṫ  Input is n (e.g. 5)
                  ṫ  Range from input to 1: [5,4,3,2,1]
                 t   Drop first element: [4,3,2,1]
             e1_1    The list [1,-1]
            ¢        repeated infinitely: [1,-1,1,-1,..
          `Ṙ         Clone with respect to the list above: [1,1,1,1,-1,-1,-1,1,1,-1]
         ∫           Cumulative sum: [0,1,2,3,4,3,2,1,2,3,2]
mo                   For each element k (e.g. 3) do this:
      R'             Repeat space k times: "   "
  `:'#               Append '#': "   #"
                     Print implicitly separated by linefeeds.

Python 3，82字节

def z(n):l=range(1,n);print(8);exec("[print(' '*i+'8')for i in l];l=l[-2::-1];"*n)

在线尝试！

视网膜，71字节

.+
$* 
^
:>
 $
:
;{*T`:<>`_#
( ) >(:)|( )<
$1<$2$3
(:)( )<|>( )
$2$1$3>

在线尝试！说明：前三个阶段将输入转换:> :为:s 之间的字符数为输入数的形式。然后，最后两个阶段在s 之间反弹>（或<，当向左移动时）:。第四阶段循环弹跳，每次打印字符串的所需部分。在;停止从在循环之后被印刷的字符串。

05AB1E，16个字节

Î<L¤F¦})˜Ôð×X«»

在线尝试！

说明

Î<L               # push 0 and range [1 ... input-1]
   ¤              # get the last element of the list
    F             # that many times do
     Â            # bifurcate
      ¦           # remove the head
       })˜        # end loop and wrap in flattened list
          Ô       # remove consecutive duplicates
           ð×     # repeat space a number of times corresponding to each number in the list
             X«   # append 1 to each
               »  # join on newline

K（Kona），27个字节

`0:{|x$"#"}'1,,/{1_|x}\-2-!

通过反复反转和降低向量的头直到为空来产生基础的数字序列。

PHP，65字节

<?while(--$n||$n=$d=--$argn)echo str_pad("X
",2+$x-=$d&1?:-1);?>X

作为管道运行-nF或在线测试。

说明：

第一次迭代：$nis NULL，所以--$n没有任何效果，其结果为NULL
-> set $n并$d预减参数
1. $x偶数递增$d，奇数递减$d
2. print X，换行符和$x空格

进一步迭代：递减$n；当它命中时0，将$n（和$d）重置为递减的参数

结局：再打印一张X。

Japt，31个字节

Ç+V ç +QÃê ¯-2 c´U?ß´UVÄ :Vç +Q

返回行数组的递归解决方案。

在线尝试！使用该-R标志将输出与换行符连接在一起。

Python 2中，159个 145 141 136字节

print"".join([" "*p+"#\n"for p in(lambda l:[sum(l[:i])for i in range(len(l))])(sum([i*[1-i%2*2]for i in range(input())[::-1]],[])+[1])])

已经有相当不错的Python版本可以解决此问题，但我认为我仍然会发布糟糕的单行代码。（虽然没有分号！）

编辑：减少14个字节，使用总和而不是双列表理解

编辑：刚在python 2中注意到，您可以使用输入而不是raw_input。我一直只是使用后者。

Mathematica，142102字节（独立）

此解决方案具有数学上的味道：

UnitVector[#,1-Sum[(-1)^Floor[#+1/2-Sqrt[9/4+#*#-#-2x]],{x,k}]]~Table~{k,0,#(#-1)/2}/.{0->" ",1->"X"}&

基本上，这将计算我们所处的段（通过反转三角数函数），然后通过加上-1的幂来左右移动。

您可以在Wolfram代码沙箱中通过粘贴类似的代码UnitVector[#,1-Sum[(-1)^Floor[#+1/2-Sqrt[9/4+#*#-#-2x]],{x,k}]]~Table~{k,0,#(#-1)/2}/.{0->" ",1->"X"}&@6//MatrixForm并按Shift + Enter或Numpad Enter或单击Gear->“评估单元”来对其进行测试。

这恰好与我原来使用Erik的Python 2解决方案的不正确端口的长度相同（此端口为输入提供更高的输出）：

(Print[X];l=Range@#;Do[Do[Print[StringRepeat[" ",l[[j]]]<>"X"],{j,Length@l}];l=l[[-2;;1;;-1]],{i,#}])&