Sfida

Creerai un programma / funzione che accetta un input di stringa di lunghezza ne:

1. Mette il kthcarattere al centro dello spazio, dove k = (n+1)/2. Questa sarà la posizione del tuo ground zero.
2. Mette il resto dei caratteri non bianchi disposti casualmente attorno al ground zero. La distanza di Pitagora dal personaggio non deve superare n.
3. Emette il risultato.

Se hai bisogno di chiarimenti, vedi l'esempio seguente.

Regole

• Si applicano scappatoie standard!
• L'I / O deve essere sotto forma di stringa.
• L'input sarà sempre strano per assicurarti di avere un carattere centrale da mettere a ground zero.
• Ogni output valido dovrebbe verificarsi con una probabilità diversa da zero.

Questo è code-golf ; vince il codice più corto in byte!

Esempio

Ingresso: qwert

I confini dell'esplosione che emana dal ground zero (i segni di x sono validi per il resto dei caratteri):

     x
  xxxxxxx
 xxxxxxxxx
 xxxxxxxxx
 xxxxxxxxx
xxxxxexxxxx
 xxxxxxxxx
 xxxxxxxxx
 xxxxxxxxx
  xxxxxxx
     x

Esempio di output:

       t
     r

q    e


      w

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

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

Provalo online!

{ } funzione anonima con argomento ⍵

n←≢⍵variabile nè la lunghezza

s←2⍴1+2×nvariabile sè la forma del risultato: 2n + 1 di 2n + 1

''⍴⍨s crea un quadrato di spazi con quella forma

A@I⊢Bmette gli elementi Ain (coppie di) indici Inella matriceB

+.ר⍨n-⍳s distanze quadrate dal centro della matrice

(××n≥*∘.5) matrice booleana che indica dove quelle distanze sono diverse da zero e ≤n

⍸ coppie di coordinate per gli 1 nella matrice booleana

i[n?≢i← ... ] scegline n casualmente (nessun duplicato)

n⊣¨¨@(⊢≡¨⌽) cambia quello centrale in n n

⍵@( ... )⊢ ... metti i caratteri dall'argomento in corrispondenza degli indici indicati nella matrice degli spazi

JavaScript (ES6), 211 216 220

Modifica 1 byte salvato grazie a @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`
`

Test

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>

Rubino, 211 207 203 196 caratteri

Grazie a edc65 per 4 personaggi

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

Spiegazione:

->(x){...} definire una funzione anonima che accetta un argomento x

x=x.charssi trasforma xda una stringa in una matrice di stringhe di un carattere

o,b,c=x.sizememorizzare la lunghezza dell'input oper un uso successivo. be cdevono semplicemente essere inizializzati su qualcosa , quindi salva 2 caratteri allegandoli a un compito precedente.

l=o*2+1 questa è la lunghezza / larghezza del campo in cui tutti i personaggi potrebbero eventualmente andare, anche il diametro del cerchio di esplosione.

Array.new(l){Array.new l,' '}fare una lx ldimensionato 2D array di caratteri di spazio.

a[o][o]=x.delete_at o/2imposta il centro dell'array al centro dei valori di x(input), eliminando tale valore dax

... while x[0]eseguire il blocco (in questo caso, il codice prima whileperché è in linea) ripetutamente fino a quando non xè vuoto. In ruby, ritorna l'accesso a un indice che non esiste nil, che è un valore falso.

a[b=rand(l)][c=rand(l)]==' 'Assegnare be cvalori casuali dove 0 <= n < l. Quindi controlla se il punto in b, cè vuoto (aka è impostato sul carattere spazio)

(b-o)**2+(c-o)**2<=o*oControllo della distanza di Pitagora. oè la lunghezza dell'input. **è l'operatore esponenziale di Ruby ed val<=o*oè più corto di val**0.5<=o.

a[b][c]=x.popelimina l'ultimo valore da x. Impostare la posizione a, ba quel valore in matricea

a[b][c]=x.pop if a[b=rand(l)][c=rand(l)]==' '&&(b-o)**2+(c-o)**2<=o*o while x[0]Impostare una posizione casuale sull'ultimo valore se quella posizione è libera e si trova nel raggio di esplosione; continua a farlo finché non finiamo i personaggi da posizionare.

$/è impostato sulla nuova riga del sistema operativo. È anche più corto di"\n"

a.map(&:join).join $/Mappare tutti gli array in auna versione a stringa singola di se stessi (ad es. ['a','b','c']-> 'abc'). Prendi quel nuovo array e unisciti a esso con le nuove linee. Ritorno implicito.

Python 3 , 286 byte

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)

Provarlo online è un'opzione.

Whoops, inciampato su questo a causa della recente attività, non si è accorto che aveva più di due anni in qualche modo fino a quando non ho trascorso un bel po 'su questo. Bene, due risposte sono un po 'tristi, quindi questa è probabilmente una buona idea pubblicare comunque. Sono sicuro che ci sono dozzine di modi per migliorarlo: non ho notato fino ad ora che l'input è sempre strano, il che sarebbe stato utile sapere.

Spiegazione

i=input()Questo input, ovviamente, l=len(i)sta salvando la lunghezza della stringa perché viene usata parecchie volte.

a=range(-l,l+1) - uno strumento rapido per creare un iteratore che allontani le distanze disponibili dall'origine in entrambe le direzioni lungo una dimensione.

g=[(y,x)for y in a for x in a] costruisce un elenco di coordinate tuple che compongono l'intera griglia finale.

p=[(y,x)for y,x in g if abs(x+y*1j)<=l and x|y] crea un sottoinsieme dell'elenco contenente solo le coordinate su cui possono eventualmente atterrare lettere non centrali.

m=i[l//2] stabilisce il personaggio centrale.

d=[*i.replace(m,"",1).center(len(p))]- il personaggio centrale viene eliminato, lasciandoci con gli altri detriti. La center()funzione è molto bella qui, perché ci consente di tracciare la linea (con uno spazio di default) fino a quando non è lungo un certo numero di caratteri. Ecco, questo è il numero di spazi su cui le lettere possono atterrare, rispecchiando così la distribuzione di cui abbiamo bisogno.

r.shuffle(d) mescola naturalmente la distribuzione in realtà ... distribuita.

Il loop, for c in g: o+=m if c==(0,0)else d.pop()if c in p else" "guarda l'intero quadrato di tessere fattibili, indipendentemente da qualsiasi cosa possibilmente atterrare su di esso o meno, e, se necessario, aggiunge un carattere alla nostra stringa di output o. I personaggi vengono estratti dal nostro campione di detriti in modo che appaiano solo una volta.

if c[1]==l:o+="\n"- Aggiunge anche le interruzioni di riga. Ritorna.