挑战

您将要编写一个程序，接受长度为的字符串输入n：

1. 将kthchar 放在空间的中心，在k = (n+1)/2。这将是地面零的位置。
2. 将其余的非空白char随机放置在地面零附近。毕达哥拉斯与炭黑的距离不得超过n。
3. 输出结果。

如果需要澄清，请参见下面的示例。

规则

• 有标准漏洞！
• I / O必须采用字符串形式。
• 输入将始终为奇数，以确保将中央字符置于零地。
• 每个有效输出的发生概率均应为非零。

这是代码高尔夫球；以字节为单位的最短代码胜出！

例

输入： qwert

爆炸的边界从地面零开始（x标记其余字符为有效位置）：

     x
  xxxxxxx
 xxxxxxxxx
 xxxxxxxxx
 xxxxxxxxx
xxxxxexxxxx
 xxxxxxxxx
 xxxxxxxxx
 xxxxxxxxx
  xxxxxxx
     x

输出示例：

       t
     r

q    e


      w

APL（Dyalog Classic），68 66 65 63 62字节

{⍵@(n⊣¨¨@(⊢≡¨⌽)i[n?≢i←⍸(××n≥*∘.5)+.ר⍨n-⍳s])⊢''⍴⍨s←2⍴1+2×n←≢⍵}

在线尝试！

{ } 带参数的匿名函数 ⍵

n←≢⍵ 变量 n是长度

s←2⍴1+2×n 变量 s是结果的形状：2n + 1 x 2n + 1

''⍴⍨s 创建具有该形状的空间正方形

A@I⊢B将元素放在矩阵的A（对）索引I处B

+.ר⍨n-⍳s 距矩阵中心的平方距离

(××n≥*∘.5) 布尔值矩阵，指示这些距离在哪里非零且 ≤n

⍸ 布尔矩阵中1的坐标对

i[n?≢i← ... ] 随机选择n个（无重复项）

n⊣¨¨@(⊢≡¨⌽) 换一个 n n

⍵@( ... )⊢ ... 将参数中的字符放在空间矩阵中给定索引处

JavaScript（ES6），211 216 220

编辑保存的1个字节thx @usandfriends

s=>[...s].map((c,i)=>{for(R=_=>Math.random()*h-l|0;x=R(y=R()),!(i-(l/2|0)?x|y&&x*x+y*y<=l*l&g[y+=l][x+=l]<'!':x=y=l););z=[...g[y]],z[x]=c,g[y]=z.join``},l=s.length,g=Array(h=l-~l).fill(' '.repeat(h)))&&g.join`
`

测试

f=s=>[...s].map((c,i)=>{for(R=_=>Math.random()*h-l|0;x=R(y=R()),!(i-(l/2|0)?x|y&&x*x+y*y<=l*l&g[y+=l][x+=l]<'!':x=y=l););z=[...g[y]],z[x]=c,g[y]=z.join``},l=s.length,g=Array(h=l-~l).fill(' '.repeat(h)))&&g.join`
`

// Less golfed
U=s=>(
  l=s.length,
  h=l-~l, // l+l+1
  g=Array(h).fill(' '.repeat(h)),
  [...s].map((c,i)=>{
    for(R=_=>Math.random()*h-l|0;
        x=R(y=R()), // set x,y to a random value in range -l ... l
        !(i - (l/2|0) // check if at mid point of input string
          ? x|y && // if not, check x and y must not be both 0
            x*x + y*y <= l*l &  // then check position inside the circle of ray L
            g[y+=l][x+=l] < '!' // then add offset L and check if position is not already used 
          : x=y=l // if at midpoint in input string, x and y have fixed value L
         );
       ); // loop until valid position found
    z = [...g[y]];  // modify string at current position: convert to array ...
    z[x] = c;       // ... set element ...
    g[y] = z.join`` // ... back to string
  }),
  g.join`\n`
)  

setInterval(_=>O.textContent=(f(I.value)),1000)

Word <input id=I value='qwert'><pre id=O></pre>

红宝石， 211 207 203 196个字符

感谢edc65为4个字符

->(x){x=x.chars
o,b,c=x.size
l=o*2+1
a=Array.new(l){Array.new l,' '}
a[o][o]=x.delete_at o/2
a[b][c]=x.pop if a[b=rand(l)][c=rand(l)]==' '&&(b-o)**2+(c-o)**2<=o*o while x[0]
a.map(&:join).join $/}

说明：

->(x){...} 定义一个接受参数的匿名函数 x

x=x.chars变换x从字符串转换成一个字符的字符串的数组

o,b,c=x.size存储输入的长度以o供以后使用。b并且c只需将其初始化为something，因此通过附加到先前的赋值来保存2个字符。

l=o*2+1 这是所有字符都可能到达的字段的长度/宽度，也是爆炸圆的直径。

Array.new(l){Array.new l,' '}制作一个lx l尺寸的2D空格字符数组。

a[o][o]=x.delete_at o/2将数组的中心设置为x（输入）值的中心，同时从中删除该值x

... while x[0]while一遍又一遍地运行该块（在这种情况下，因为之前是内联的，所以之前的代码）直到x为空。在ruby中，访问不存在的索引将返回nil，这是一个false值。

a[b=rand(l)][c=rand(l)]==' '分配b和c给0 <= n <的随机值l。然后检查是否在现场b，c是空的（也就是设置为空格字符）

(b-o)**2+(c-o)**2<=o*o勾股距离检查。o是输入的长度。**是ruby的幂运算符，并且val<=o*o比短val**0.5<=o。

a[b][c]=x.pop从中删除最后一个值x。设定的位置a，b以在数组值a

a[b][c]=x.pop if a[b=rand(l)][c=rand(l)]==' '&&(b-o)**2+(c-o)**2<=o*o while x[0]如果该位置是自由的并且在爆炸半径之内，则将随机位置设置为最后一个值；继续这样做，直到我们用完所有字符为止。

$/设置为操作系统的换行符。也比"\n"

a.map(&:join).join $/将所有数组映射a到其自身的单字符串版本（例如['a','b','c']-> 'abc'）。选择该新数组，并使用换行符将其加入。隐式回报。

Python 3，286字节

import random as r
i=input()
l=len(i)
a=range(-l,l+1)
g=[(y,x)for y in a for x in a]
p=[(y,x)for y,x in g if abs(x+y*1j)<=l and x|y]
m=i[l//2]
d=[*i.replace(m,"",1).center(len(p))]
r.shuffle(d)
o=""
for c in g:
	o+=m if c==(0,0)else d.pop()if c in p else" "
	if c[1]==l:o+="\n"
print(o)

在线尝试是一种选择。

哎呀，由于最近的活动而偶然发现了它，直到我花了很多时间才注意到它已经超过两年了。好吧，两个答案有点令人遗憾，因此无论如何这可能是一个好主意。我敢肯定，有很多方法可以改善这一点，直到现在才知道输入总是奇怪，这对我们很有帮助。

说明

i=input()输入当然l=len(i)会节省字符串的长度，因为使用了很多次。

a=range(-l,l+1) —一个快速的工具，用于创建迭代器，该迭代器沿一维双向定位距原点的可用距离。

g=[(y,x)for y in a for x in a] 建立一个组成整个最终网格的元组坐标列表。

p=[(y,x)for y,x in g if abs(x+y*1j)<=l and x|y] 创建列表的子集，其中仅包含非中心字母可能会落在的坐标。

m=i[l//2] 确定中心字符。

d=[*i.replace(m,"",1).center(len(p))]-取出中心角色，剩下其他碎片。的center()函数在这里非常好用，因为它允许我们填充行（默认情况下带有空格），直到其长度达到一定数量的字符为止。在这里，这是字母可以落在的空间数量，因此反映了我们所需的分布。

r.shuffle(d) 自然地改变了所说的分配实际上是……分配。

循环会for c in g: o+=m if c==(0,0)else d.pop()if c in p else" "查看可行的方块的整个正方形，而不管其上是否有可能落下的任何东西，并在必要时在输出字符串中添加一个字符o。字符从我们的碎片样本中弹出，因此只能出现一次。

if c[1]==l:o+="\n"—也添加换行符。退货。