Un sauteur est une catégorie de pièce d'échecs de fée qui se déplace en "sautant". Un chevalier normal est un (1,2) -leaper, ce qui signifie que chaque mouvement implique de déplacer une distance de 1 carré dans une direction orthogonale et 2 carrés dans la direction perpendiculaire.

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

Il existe de nombreux sauteurs différents. Le (1,3) -leaper est appelé le Long Knight ou Camel. Son motif de déplacement ressemble à ceci:

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

Il y a aussi le (2,2) Alfil ...

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

... et même le (0,1) Wazir.

.o.
oWo
.o.

Défi

Étant donné une paire de nombres en entrée, sortez le diagramme de mouvement correspondant. Vous pouvez écrire un programme ou une fonction, avec une entrée fournie via STDIN / ligne de commande ou comme argument, et la sortie fournie par STDOUT ou la valeur de retour. C'est du code-golf .

Contribution

L'entrée sera une liste séparée par des virgules de deux entiers et une lettre majuscule. Les deux entiers seront dans la plage 0-7(inclus) et dans l'ordre non décroissant. Retour à la ligne en option pour l'entrée et la sortie.

Voici les entrées pour les quatre exemples ci-dessus:

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

Production

La sortie sera une chaîne multiligne carrée. La lettre majuscule sera placée au centre pour représenter l'emplacement actuel de la pièce. Les emplacements de mouvement seront représentés par 4 ou 8 minusculeso . Tous les autres espaces de la place seront remplis de points.

Si le modèle de mouvement est 0,0, sortez uniquement la lettre majuscule.

À titre indicatif, si le deuxième entier (le plus grand) a la valeur N, alors le carré aura toujours une longueur de côté 2N + 1. Les os seront toujours sur le périmètre du carré.

Cas de test supplémentaires

1,1,F

o.o
.F.
o.o

5,7,Q

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


0,0,J

J

Rubis, 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 testé dans le programme de 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 octets

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

J'apprends Pyth! Essayez-le .

Explication

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 octets

(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)

Où se \ntrouve le nouveau caractère de ligne littéral. Fonctionne en générant le quadrant inférieur droit et en le reflétant le long des deux axes.

Edit: sauvé 2 octets grâce à @ edc65.

(Je suis arrivé ici via une question en double qui a permis un résultat de tableau qui aurait été 19 octets plus court, mais ne garantissait pas un ordre non décroissant, ce qui a gaspillé 8 octets.)

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`
`

Moins 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')
}

Tester

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>