Défi

Vous allez créer un programme / une fonction qui prend une entrée de chaîne de longueur net:

1. Place l' kthomble au centre de l'espace, où k = (n+1)/2. Ce sera l'emplacement de votre Ground Zero.
2. Place le reste des caractères non blancs disposés de manière aléatoire autour du zéro du sol. La distance pythagoricienne du char ne doit pas dépasser n.
3. Sort le résultat.

Si vous avez besoin de clarifications, consultez l'exemple ci-dessous.

Règles

• Les échappatoires standard s'appliquent!
• Les E / S doivent être sous la forme d'une chaîne.
• L'entrée sera toujours étrange pour vous assurer d'avoir un caractère central à mettre à zéro.
• Chaque sortie valide doit se produire avec une probabilité non nulle.

C'est du golf de code ; le code le plus court en octets gagne!

Exemple

Contribution: qwert

Les limites de l'explosion émanant de Ground Zero (la marque de x est valide pour le reste des caractères):

     x
  xxxxxxx
 xxxxxxxxx
 xxxxxxxxx
 xxxxxxxxx
xxxxxexxxxx
 xxxxxxxxx
 xxxxxxxxx
 xxxxxxxxx
  xxxxxxx
     x

Exemple de sortie:

       t
     r

q    e


      w

APL (Dyalog Classic) , 68 66 65 63 62 octets

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

Essayez-le en ligne!

{ } fonction anonyme avec argument ⍵

n←≢⍵variable nest la longueur

s←2⍴1+2×nvariable sest la forme du résultat: 2n + 1 par 2n + 1

''⍴⍨s créer un carré d'espaces avec cette forme

A@I⊢Bplace les éléments Aà (paires) d'indices Idans la matriceB

+.ר⍨n-⍳s distances au carré du centre de la matrice

(××n≥*∘.5) matrice booléenne indiquant où ces distances sont non nulles et ≤n

⍸ paires de coordonnées pour les 1 dans la matrice booléenne

i[n?≢i← ... ] choisissez n d'entre eux au hasard (pas de doublons)

n⊣¨¨@(⊢≡¨⌽) changer le central en n n

⍵@( ... )⊢ ... mettre les caractères de l'argument aux indices donnés dans la matrice des espaces

JavaScript (ES6), 211 216 220

Modifier 1 octet enregistré 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`
`

Tester

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>

Rubis, 211 207 203 196 caractères

Merci à edc65 pour 4 personnages

->(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 $/}

Explication:

->(x){...} définir une fonction anonyme qui prend un argument x

x=x.charstransformer xd'une chaîne en un tableau de chaînes à un caractère

o,b,c=x.sizestocker la longueur de l'entrée opour une utilisation ultérieure. bet cdoivent simplement être initialisés à quelque chose , alors enregistrez 2 caractères en les attachant à une affectation précédente.

l=o*2+1 il s'agit de la longueur / largeur du champ où tous les personnages pourraient éventuellement aller, ainsi que du diamètre du cercle d'explosion.

Array.new(l){Array.new l,' '}créer un tableau 2D de taille lx lde caractères d'espace.

a[o][o]=x.delete_at o/2définit le centre du tableau au centre des valeurs de x(l'entrée), tout en supprimant cette valeur dex

... while x[0]exécutez le bloc (dans ce cas, le code avant whilecar il est en ligne) encore et encore jusqu'à ce qu'il xsoit vide. En rubis, l'accès à un index qui n'existe pas revient nil, ce qui est une valeur de falsey.

a[b=rand(l)][c=rand(l)]==' 'Attribuez bet cà des valeurs aléatoires où 0 <= n < l. Ensuite, vérifiez si l'endroit à b, cest vide (aka est défini sur le caractère espace)

(b-o)**2+(c-o)**2<=o*oVérification de la distance pythagoricienne. oest la longueur de l'entrée. **est l'opérateur d'exponentiation de ruby, et val<=o*oest plus court que val**0.5<=o.

a[b][c]=x.popsupprimer la dernière valeur de x. Définissez la position a, bà cette valeur dans le tableaua

a[b][c]=x.pop if a[b=rand(l)][c=rand(l)]==' '&&(b-o)**2+(c-o)**2<=o*o while x[0]Définissez une position aléatoire sur la dernière valeur si cette position est libre et se trouve dans le rayon d'explosion; continuez ainsi jusqu'à ce que nous manquions de caractères à placer.

$/est défini sur la nouvelle ligne du système d'exploitation. Il est également plus court que"\n"

a.map(&:join).join $/Mappez tous les tableaux dans aune version à chaîne unique d'eux-mêmes (par exemple ['a','b','c']-> 'abc'). Prenez ce nouveau tableau et joignez-le à des nouvelles lignes. Retour implicite.

Python 3 , 286 octets

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)

L'essayer en ligne est une option.

Oups, tombé sur ce sujet en raison d'une activité récente, n'a pas remarqué qu'il avait plus de deux ans jusqu'à ce que j'y passe un bon moment. Eh bien, deux réponses sont un peu tristes, c'est donc probablement une bonne idée de poster quand même. Je suis sûr qu'il existe des dizaines de façons d'améliorer cela - je n'ai pas remarqué jusqu'à présent que les commentaires sont toujours étranges, ce qui aurait été utile de savoir.

Explication

i=input()l=len(i)Cette entrée, bien sûr, enregistre la longueur de la chaîne car elle est utilisée plusieurs fois.

a=range(-l,l+1) - un outil rapide pour créer un itérateur allant des distances disponibles loin de l'origine dans les deux sens le long d'une dimension.

g=[(y,x)for y in a for x in a] construit une liste de coordonnées de tuple qui constitue la grille finale entière.

p=[(y,x)for y,x in g if abs(x+y*1j)<=l and x|y] crée un sous-ensemble de la liste contenant uniquement les coordonnées sur lesquelles les lettres non centrales peuvent éventuellement atterrir.

m=i[l//2] établit le caractère central.

d=[*i.replace(m,"",1).center(len(p))]- le personnage central est sorti, nous laissant avec les autres débris. La center()fonction est très agréable ici, car elle nous permet de remplir la ligne (avec par défaut un espace) jusqu'à ce qu'elle soit longue d'un certain nombre de caractères. Ici, c'est le nombre d'espaces sur lesquels les lettres peuvent atterrir, reflétant ainsi la distribution dont nous avons besoin.

r.shuffle(d) mélange naturellement ladite distribution comme étant réellement ... distribuée.

La boucle,, for c in g: o+=m if c==(0,0)else d.pop()if c in p else" "regarde le carré entier des tuiles réalisables, indépendamment de tout ce qui peut y atterrir ou non, et si nécessaire, ajoute un caractère à notre chaîne de sortie o. Les personnages sont extraits de notre échantillon de débris afin qu'ils n'apparaissent qu'une seule fois.

if c[1]==l:o+="\n"- Ajoute également des sauts de ligne. Retour.