Un leaper è una categoria di pezzi degli scacchi delle fate che si muove "saltando". Un cavaliere normale è un (1,2) -foglia, il che significa che ogni mossa comporta lo spostamento di una distanza di 1 quadrato in direzione ortogonale e 2 quadrati in direzione perpendicolare.

.o.o.
o...o
..N..
o...o
.o.o.

Ci sono molti diversi saltatori. La foglia (1,3) si chiama Long Knight o Camel. Il suo modello di spostamento è simile al seguente:

..o.o..
.......
o.....o
...L...
o.....o
.......
..o.o..

C'è anche il (2,2) Alfil ...

o...o
.....
..A..
.....
o...o

... e persino il (0,1) Wazir.

.o.
oWo
.o.

Sfida

Data una coppia di numeri come input, emette il diagramma di movimento corrispondente. È possibile scrivere un programma o una funzione, con input fornito tramite STDIN / riga di comando o come argomento e output fornito da STDOUT o dal valore restituito. Questo è code-golf .

Ingresso

L'input sarà un elenco separato da virgole di due numeri interi e una lettera maiuscola. I due numeri interi saranno 0-7compresi nell'intervallo (incluso) e in ordine non decrescente. Newline finale opzionale per input e output.

Ecco gli input per i quattro esempi precedenti:

1,2,N
1,3,L
2,2,A
0,1,W

Produzione

L'output sarà una stringa multilinea di forma quadrata. La lettera maiuscola verrà posizionata al centro per rappresentare la posizione corrente del pezzo. Le posizioni dei movimenti saranno rappresentate da 4 o 8 lettere minuscole o. Tutti gli altri spazi nella piazza saranno riempiti con punti.

Se lo schema di movimento è 0,0, genera solo la lettera maiuscola.

Come suggerimento, se il secondo numero intero (quello più grande) ha valore N, il quadrato avrà sempre una lunghezza laterale 2N + 1. Le os saranno sempre sul perimetro della piazza.

Test aggiuntivi

1,1,F

o.o
.F.
o.o

5,7,Q

..o.........o..
...............
o.............o
...............
...............
...............
...............
.......Q.......
...............
...............
...............
...............
o.............o
...............
..o.........o..


0,0,J

J

Rubino, 107

->a,b,n{(-b..b).map{|i|s='..'*b+?.
i%b==0&&(i==0?s[b]=n :s[b+a]=s[b-a]=?o)
i.abs==a&&s[0]=s[-1]=?o
puts s}}

Non registrato nel programma di test

f=->a,b,n{
  (-b..b).map{|i|                           #iterate from -i to i (lines of grit)
    s='..'*b+?.                             #make a string of 2n+1 .'s
    i%b==0&&(i==0?s[b]=n :s[b+a]=s[b-a]=?o) #if i%b=0 plot the centre character (if i=0) or the o's on the top and bottom rows
    i.abs==a&&s[0]=s[-1]=?o                 #if i.abs=a plot the o's in left and right columns
    puts s                                  #having substituted the .'s with o and centre as necessary, output the current line
  }
}

a=gets.to_i
b=gets.to_i
n=gets.chop
f[a,b,n]

Pyth, 40 byte

JASv<2zFZK+rH_1SHFY,LZKp?qJSY\o?sY\.ez)k

Sto imparando Pyth! Provalo .

Spiegazione

J             J =
 A                (G, H) =
  S                        sorted(
   v<2z                           eval(input[:-2]))

FZK+rH_1SH    for Z in K = [H, H-1, ..., 0] + [1, 2, ..., H]:
  FY,LZK          for Y in [(Z, k) for k in K]:
    p                 print the following value without newline:
     ?qJSY\o              if J = sorted(Y): 'o'
       ?sY\.              if sum(Y) != 0:   '.'
         ez               else:             input[-1]
  )               end for
k                 print newline

JavaScript (ES6), 163 161 145 byte

(x,y,c,m=a=>`\n`+a.slice(1).reverse().join``+a.join``,a=Array(y+1).fill`.`,q=a.map(_=>[...a]))=>m(q.map(m,q[x][y]=q[y][x]='o',q[0][0]=c)).slice(2)

Dov'è \nil carattere letterale della nuova linea. Funziona generando il quadrante in basso a destra e specchiandolo lungo entrambi gli assi.

Modifica: salvato 2 byte grazie a @ edc65.

(Sono arrivato qui tramite una domanda duplicata che ha permesso un risultato di array che sarebbe stato più breve di 19 byte, ma non ha garantito un ordine non decrescente, che ha sprecato 8 byte.)

JavaScript (ES6) 144 150

(a,b,c,g=Array(b-~b).fill`.`)=>(g=g.map(x=>[...g])).map(x=>x.join``,[b-a,b+a].map(t=>g[t][0]=g[0][t]=g[t][2*b]=g[2*b][t]='o'),g[b][b]=c).join`
`

Meno golf

(a,b,c)=> {
  var g=Array(b*2+1).fill('.');
  g=g.map(x=>[...g]);
  var q=(t)=>
    g[t][0] =
    g[0][t] =
    g[t][2*b] =
    g[2*b][t] = 'o';
  q(b+a);
  q(b-a);
  g[b][b] = c;
  return g.map(x=> x.join('')).join('\n')
}

Test

f=(a,b,c,g=Array(b-~b).fill`.`)=>(g=g.map(x=>[...g])).map(x=>x.join``,[b-a,b+a].map(t=>g[t][0]=g[0][t]=g[t][2*b]=g[2*b][t]='o'),g[b][b]=c).join`
`

console.log=x=>O.textContent+=x+'\n'

t=`1,2,N
1,3,L
2,2,A
0,1,W
1,1,F
5,7,Q`.split`\n`
.forEach(t=>([x,y,z]=t.split`,`, console.log(t+'\n'+f(+x,+y,z)+'\n')))

<pre id=O></pre>