Un saltador es una categoría de pieza de ajedrez de hadas que se mueve "saltando". Un caballero normal es un (1,2) -leaper, lo que significa que cada movimiento implica mover una distancia de 1 cuadrado en una dirección ortogonal y 2 cuadrados en la dirección perpendicular.

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

Hay muchos saltadores diferentes. El (1,3) -leaper se llama Long Knight, o Camel. Su patrón de movimiento se ve así:

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

También está el (2,2) Alfil ...

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

... e incluso el (0,1) Wazir.

.o.
oWo
.o.

Desafío

Dado un par de números como entrada, genera el diagrama de movimiento correspondiente. Puede escribir un programa o función, con la entrada proporcionada a través de STDIN / línea de comandos o como argumento, y la salida proporcionada por STDOUT o el valor de retorno. Este es el código de golf .

Entrada

La entrada será una lista separada por comas de dos enteros y una letra mayúscula. Los dos enteros estarán en el rango 0-7(inclusive) y en orden no decreciente. Nueva línea final opcional para entrada y salida.

Aquí están las entradas para los cuatro ejemplos anteriores:

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

Salida

La salida será una cadena multilínea de forma cuadrada. La letra mayúscula se colocará en el centro para representar la ubicación actual de la pieza. Las ubicaciones de movimiento estarán representadas por 4 u 8 minúsculas o. Todos los demás espacios en el cuadrado se llenarán con puntos.

Si el patrón de movimiento es 0,0, escriba solo la letra mayúscula.

Como pista, si el segundo entero (el más grande) tiene un valor N, entonces el cuadrado siempre tendrá una longitud lateral 2N + 1. El os siempre estará en el perímetro del cuadrado.

Casos de prueba adicionales

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

Sin golf en el programa de prueba

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 bytes

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

Estoy aprendiendo Pyth! Probarlo .

Explicación

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)

¿Dónde \nestá el carácter literal de la nueva línea? Funciona generando el cuadrante inferior derecho y reflejándolo a lo largo de ambos ejes.

Editar: Guardado 2 bytes gracias a @ edc65.

(Llegué aquí a través de una pregunta duplicada que permitió un resultado de matriz que habría sido 19 bytes más corto, pero no garantizó un orden no decreciente, que desperdició 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 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')
}

Prueba

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>