Um saltador é uma categoria de peça de xadrez de fada que se move "pulando". Um cavaleiro normal é um (1,2) -leaper, significando que cada movimento envolve mover uma distância de 1 quadrado em uma direção ortogonal e 2 quadrados na direção perpendicular.

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

Existem muitos saltadores diferentes. O (1,3) -leaper é chamado de Cavaleiro Longo, ou Camelo. Seu padrão de movimento é assim:

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

Há também o (2,2) Alfil ...

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

... e até o (0,1) Wazir.

.o.
oWo
.o.

Desafio

Dado um par de números como entrada, imprima o diagrama de movimento correspondente. Você pode escrever um programa ou função, com a entrada fornecida via STDIN / linha de comando ou como argumento, e a saída fornecida por STDOUT ou o valor de retorno. Isso é código-golfe .

Entrada

A entrada será uma lista separada por vírgula de dois números inteiros e uma letra maiúscula. Os dois números inteiros estarão no intervalo 0-7(inclusive) e em ordem não decrescente. Trailing newline opcional para entrada e saída.

Aqui estão as entradas para os quatro exemplos acima:

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

Resultado

A saída será uma sequência multilinha em formato quadrado. A letra maiúscula será colocada no centro para representar a localização atual da peça. Os locais dos movimentos serão representados por 4 ou 8 letras minúsculas o. Todos os outros espaços da praça serão preenchidos com pontos.

Se o padrão de movimento for 0,0, imprima apenas a letra maiúscula.

Como sugestão, se o segundo inteiro (o maior) tiver valor N, o quadrado sempre terá o comprimento lateral 2N + 1. Os osempre estarão no perímetro do quadrado.

Casos de teste adicionais

1,1,F

o.o
.F.
o.o

5,7,Q

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


0,0,J

J

Ruby, 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}}

Ungolfed in program program

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]

Pitão, 40 bytes

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

Estou aprendendo Pyth! Experimente .

Explicação

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 bytes

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

Onde \n está o caractere literal da nova linha. Funciona gerando o quadrante inferior direito e espelhando-o nos dois eixos.

Editar: salvou 2 bytes graças a @ edc65.

(Cheguei aqui por meio de uma pergunta duplicada que permitiu um resultado de matriz que seria 19 bytes mais curto, mas não garantiu a ordem não decrescente, que desperdiçou 8 bytes.)

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

Menos golfe

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

Teste

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>