给定一个2仅由字母字符组成的长度或更长的输入字符串，[A-Z]或者[a-z]（如果它们全部为大写或全部为小写，则选择），输出一个连续的字符串，形成双菱形图案。

输入字符串从中心线开始，并沿对角线左右延伸，直到到达输入字符串的末尾。然后，该图案沿对角线继续上下移动，直到您到达中心线为止，直到输入字符串的长度减去1。再继续上下左右回到中心线，然后上下移动向左，然后向上和向左（位于中心字符“后面”），最后向下和向左返回起始字符。

有点罗word，下面的例子可以更好地说明这一点：

"YOU"
  U   Y
 Y O U O
Y   O   U
 O Y U Y
  U   O

  ^   ^
 ↙ ↖ ↗ ↘
↘   ↗   >
 ↘ ↗ ↖ ↙
  V   V

查看YOU起始点如何从中心线开始，然后依次从右到下，然后从上到右，依此类推，直到循环回到起点。特别要注意的是Y，左上方和左上方的“ 如何”位于“之后” O，因此未显示。

进一步的例子：

"HI"
 I I
H H H
 I I

"TEST"
   E     E
  S T   T S
 T   T T   T
T     S     T
 E   E E   E
  S T   T S
   T     T

"HELLO"
    L       L
   O L     E L
  H   E   H   O
 E     H O     H
H       L       E
 E     L L     L
  L   E   L   L
   L H     E O
    O       H

• 输入和输出可以通过任何方便的方法给出。
• 确保输入的长度至少为两个字母（即，您将永远不会收到""输入）。
• 您可以将其打印到STDOUT或将其作为功能结果返回。
• 完整的程序或功能都是可以接受的。
• 只要字符适当排列（例如，随意填充为矩形），任何数量的外部空格都是可以接受的。
• 禁止出现标准漏洞。
• 这是代码高尔夫球，因此所有常用的高尔夫规则都适用，并且最短的代码（以字节为单位）获胜。

木炭，17字节

ＧＨ<↗↘>↖↙ＬθθＧＨ<Ｌθθ

在线尝试！链接是详细版本的代码。说明：

ＧＨ

沿路径绘制。

<↗↘>↖↙

按照↘↗↗↘↙↖↖↙的方向绘制（<和>是这两对的简写，但其他两对没有简写。）

Ｌθ

每个路径段的长度相同，包括输入长度的两端。

θ

使用输入作为要沿路径写入的文本。

ＧＨ<Ｌθθ

再次打印路径的前两个部分，以便中间字符正确。

05AB1E，12个字节

gIR7._•Íη•Λ

在线尝试！

           Λ    use the canvas function
g               with the length of input for each segment
 IR7._          the input reversed and rotated left by 7 characters (we will draw this backwards to have the right center character)
      •Íη•     and the directions 1, 3, 3, 1, 7, 5, 5, 7 as a compressed number. 

JavaScript（ES6），  157个155  154字节

返回字符矩阵。

s=>(y=n=s.length,y+=i=X=Y=-1,m=[...Array(y+n)].map(_=>r=Array(4*n-3).fill` `),g=x=>x?g(x-=r[m[y][++i==6*n-6||+x]=s[i%n],y-=m[y-Y]?Y:Y=-Y,x-X]?X:X=-X):m)``

在线尝试！

怎么样？

$n$$w\times h$

• $w = 4n-3$
• $h = 2n-1$

我们从开始模拟在此矩阵中弹跳的“球”$(0,n-1)$出发，向东南方向行驶，直到它回到其初始位置。

菱形中必须跳过的中心字符的从0开始的索引是：

$n=4$

已评论

s => (                           // s = input string
  y = n = s.length,              // n = length of s
  y += i = X = Y = -1,           // y = n - 1; i = X = Y = -1
  m =                            // create a matrix m[]:
    [...Array(y + n)].map(_ =>   //   - of height 2n-1
      r = Array(4 * n - 3)       //   - of width 4n-3 (save one of these rows in r[])
          .fill` `               //   - initially filled with spaces
    ),                           //
    g = x =>                     // g is a recursive function taking x
      x ?                        //   if x is truthy:
        g(                       //     do a recursive call:
          x -= r[                //       update x:
            m[y][                //         update m[y][x]:
              ++i == 6 * n - 6   //           unless this is the 2nd pass through the
              || +x              //           center cell, set it to the next character
            ] = s[i % n],        //           in s (otherwise we write to m[y][true]
                                 //           instead, which has no effect)
            y -=                 //         update y:
              m[y - Y] ? Y       //           bounce vertically if m[y - Y] is undefined
                       : Y = -Y, //
            x - X                //         bounce horizontally
          ] ? X                  //         if r[x - X] is undefined
            : X = -X             //
        )                        //     end of recursive call
      :                          //   else:
        m                        //     stop recursion and return m[]
)``                              // initial call to g with x = [''] (zero-ish but truthy)

JavaScript（ES6），136个字节

f=
(s,l=s.length-1,z=l*4,a=[...Array(l-~l)].map(_=>Array(z+1).fill` `),g=x=>x--?g(x,a[a[y=(x+l)%z]?y:z-y][x>z?z+z-x:x]=s[x%-~l]):a)=>g(z+z)

<input oninput=o.textContent=f(this.value).map(c=&gt;c.join``).join`\n`><pre id=o>

返回一个二维数组。通过将字符串绘制到数组中来工作，直接计算从末尾开始的目标坐标，以便自动覆盖中心单元格。说明：

(s

输入字符串。

,l=s.length-1

“跳动”之间的距离，也是最后一行索引的一半，比长度短一。

,z=l*4

最后一列的索引，也是绘制文本长度的一半。

,a=[...Array(l-~l)].map(_=>Array(z+1).fill` `)

空间数组。

,g=x=>x--

从最后一个单元格开始倒数。

  ?g(x

递归调用以处理剩余的单元格。

    ,a[a[y=(x+l)%z]?y:z-y]

计算此单元格的行。

      [x>z?z+z-x:x]=s[x%-~l])

计算此单元格的列以及所属单元格的字符。

  :a

通过返回数组来完成。

)=>g(z+z)

从文本末尾开始。

J，^{79 77} 75字节

(|.@$~8*])`([:;/(1,~<:@])+/\@,(_2{&1 _1\#:33495)}.@#~])`(' '$~1+2 4*])}<:@#

在线尝试！

C（铛）， 201个 196 188字节

x,y,i,v,m,n;f(s,z){char*a=s,o[i=(y=z*2-1)*(x=y+y)];for(v=x*2-2;i;n=m=1)o[--i]=i%x?32:10;for(i=x*--z;v--;i+=x*m+n)o[i]==32?o[i]=*a:0,a=*++a?a:s,n=i%x>x-3?-1:n,m=i/x?i/x<y-1?m:-1:1;puts(o);}

在线尝试！

-13 @ceilingcat建议

Python 2，137字节

s=input();n=len(s);m=2*n-2
for r in range(m+1):print''.join([s[[x,-8-x][(x<=m)==(m>2*r)]%n],' '][r!=(x+1-n)%m!=m-r]for x in range(4*n-3))

在线尝试！

将字符串作为输入的完整程序会打印出菱形版本。