El juego de damas chinas se juega en un tablero con espacios en forma de estrella de seis puntas:

^{Imagen de Wikipedia}

Podemos crear una representación ASCII-art de este tablero, utilizando .espacios vacíos y las letras GYORPBpara las seis ubicaciones iniciales de color:

            G
           G G
          G G G
         G G G G
B B B B . . . . . Y Y Y Y
 B B B . . . . . . Y Y Y
  B B . . . . . . . Y Y
   B . . . . . . . . Y
    . . . . . . . . .
   P . . . . . . . . O
  P P . . . . . . . O O
 P P P . . . . . . O O O
P P P P . . . . . O O O O
         R R R R
          R R R
           R R
            R

Para hacerlo más interesante, también podemos cambiar el tamaño. Mediremos el tamaño de un tablero por la longitud lateral de sus ubicaciones de inicio triangulares: el tablero de arriba es de tamaño 4.

Como es realmente difícil escribir todo eso a mano, ¡escriba un programa (o función) para hacerlo!

Detalles

Su código debe tener un número entero positivo que represente el tamaño de la placa, a través de STDIN, ARGV o argumento de función. Envíe el patrón de tablero de ajedrez a STDOUT (puede devolverlo alternativamente como una cadena si su envío es una función).

La salida debe

• no tener espacios finales en absoluto, o
• tener suficientes espacios finales para completar el patrón en un rectángulo perfecto de ancho 6 * N + 1.

La salida puede tener opcionalmente una nueva línea final. No se permite ningún otro espacio en blanco adicional (inicial, final).

Ejemplos

Talla 1:

   G
B . . Y
 . . .
P . . O
   R

Talla 2:

      G
     G G
B B . . . Y Y
 B . . . . Y
  . . . . .
 P . . . . O
P P . . . O O
     R R
      R

Talla 4:

            G
           G G
          G G G
         G G G G
B B B B . . . . . Y Y Y Y
 B B B . . . . . . Y Y Y
  B B . . . . . . . Y Y
   B . . . . . . . . Y
    . . . . . . . . .
   P . . . . . . . . O
  P P . . . . . . . O O
 P P P . . . . . . O O O
P P P P . . . . . O O O O
         R R R R
          R R R
           R R
            R

Tanteo

Esto es code-golf : gana el código más corto en bytes.

Rubí, 141 127

Devuelve una cadena rectangular

->n{(-2*n..2*n).map{|i|j=i.abs
k=j>n ?0:j 
(([i>0??P:?B]*k+[j>n ?i>0??R:?G:?.]*(2*n+1-j)+[i>0??O:?Y]*k)*" ").center(6*n+1)}*$/}

Sin golf en el programa de prueba

f=->n{
  (-2*n..2*n).map{|i|                    #Iterate rows from -2*n to 2*n
    j=i.abs                              #Absolute value of i
    k=j>n ?0:j                           #Value of j up to n: for PBYO
    (                                    #An array of characters forming one line
      ([i>0??P:?B]*k+                    #B or P * (k=j or 0 as appropriate)
       [j>n ?i>0??R:?G:?.]*(2*n+1-j)+    #R,G or . * (2*n+1-j) to form centre diamond
       [i>0??O:?Y]*k                     #O or Y * (k=j or 0 as appropriate)
      )*" "                              #Concatenate the array of characters into a string separated by spaces.
    ).center(6*n+1)                      #pad the string to the full width of the image, adding spaces as necessary.
  }*$/                                   #Concatenate the array of lines into a string separated by newlines.
}

puts f[gets.to_i]

Python 2, 140 bytes

n=input()
for k in range(4*n+1):x=abs(k-2*n);y=2*n-x;p,q,r=" BP G..R YO "[(k-~k)/(n-~n)::4];print(" "*y+" ".join(p*x+q*-~y+r*x)+" "*y)[n:-n]

No es genial, pero aquí está mi oferta inicial.

Las reglas de espacios en blanco agregaron muchos bytes. A modo de comparación, aquí hay un programa Python 3 de 120 bytes que solo es correcto visualmente y no sigue las reglas de espacios en blanco:

def f(n):
 for k in range(4*n+1):x=abs(k-2*n);y=2*n-x;p,q,r=" BP G..R YO "[(k-~k)//(n-~n)::4];print(" "*y,*p*x+q*-~y+r*x)

Y aquí está mi intento recursivo un poco más largo de 149 bytes de Python 3:

def f(n,k=0):x=2*n-k;s=" ".join(["B"*x+"."*-~k+"Y"*x,"G"*-~k][k<n]).center(6*n+1);print(s);k<n*2and[f(n,k+1),print(s.translate({71:82,66:80,89:79}))]

Pitón 2, 152

n=input();x=N=2*n
while~N<x:s='';y=n*3;exec"a=x+y;q=[0,a>N,x-y>N,-x>n,-a>N,y-x>N,x>n,1];s+=' BYROPG.'[q.index(sum(q)<~a%2*3)];y-=1;"*(y-~y);print s;x-=1

Este es, en retrospectiva, el enfoque incorrecto para Python, pero lo estoy publicando aquí en caso de que alguien pueda usarlo. En lugar de explicar este lío de código, trataré de decir la idea detrás de esto.

La idea es utilizar coordenadas triangulares , en los que la triangular celosía corresponde al número entero triples (a,b,c)con a+b+c=0.

(Aquí, los puntos de la red se dibujan como hexágonos).

Podemos convertir coordenadas cartesianas en triangulares como

a = (x+y)/2
b = (x-y)/2
c = -x

señalando eso xy ydebe tener la misma paridad, o de lo contrario está fuera del tablero y deberíamos imprimir un espacio.

En coordenadas triangulares, las líneas de delimitación de la estrella de seis caras tienen ecuaciones: a==n, b==n, c==n, a==-n, b==-n, c==-n.

Por lo tanto, podemos determinar en qué región nos encontramos por cuáles [a,b,c,-a,-b,-c]son mayores n.

• Si no hay ninguno, estamos en el centro e imprimimos un punto.
• Si exactamente uno es, estamos en uno de los seis triángulos exteriores e imprimimos la letra correspondiente al índice.
• Si hay dos o más, estamos fuera del tablero e imprimimos un espacio.

El rectángulo delimitador requiere que hagamos esto xen el intervalo cerrado [-2 * n, 2 * n] y yen el intervalo cerrado [-3 * n, 3 * n].

Retina , 234 bytes

.
P
.+
iP$0$0x$0j$0x$0Px$0kqw
P(?=P*xP*j)
s
P(?=P*j)
R
P(?=P*xP*k)
c
P(?=P*k)
O
x

+`i(s+R+)R
is$1#$1R
+`(s*)P(P*c*)(O*)O(?=k)
$0#s$1$2c$3
j|k
#
s

+`([^#]+#)q(.*)
q$1$2$1
R(?=.*w)
G
P(?=.*w)
B
O(?=.*w)
Y
w[^#]*#|q|i

\w
$0 
c
.
 #
#

Toma entrada en unario.

Cada línea debe ir a su propio archivo y #debe cambiarse a nueva línea en el archivo. Esto no es práctico, pero puede ejecutar el código tal como está en un archivo con la -sbandera, manteniendo el# marcadores y quizás cambiándolos a nuevas líneas en la salida para facilitar su lectura si lo desea.

El código tiene una mínima complejidad regex. Los pasos principales en la generación son los siguientes:

• Cree la última Glínea y la primera B.Ylínea (delimitada por marcadores ijky letetros usados ​​reales sonRPO ).
• Duplica la Glínea superior con un espacio más, menos una G hasta que solo haya una G.
• Duplicar la parte inferior B.Ylínea con un espacio de más y punto, un signo menos By Yhasta que no haya Be Yizquierda.
• Copie todas las líneas en orden inverso después de la cadena actual (con la ayuda del marcador q). Mantenemos un marcador ( w) en el medio.
• Cambiamos las letras RPOa GBYsi están antes del marcador.
• Agregue los espacios intermedios que faltan.

Los resultados después de cada uno de los puntos anteriores (delimitados por ='s) para la entrada 1111 (unary 4):

1111
==============================
isssssssssRRRRjPPPPcccccOOOOkqw
==============================
issssssssssssR
sssssssssssRR
ssssssssssRRR
sssssssssRRRRjPPPPcccccOOOOkqw
==============================
issssssssssssR
sssssssssssRR
ssssssssssRRR
sssssssssRRRRjPPPPcccccOOOO
sPPPccccccOOO
ssPPcccccccOO
sssPccccccccO
ssssccccccccckqw
==============================
qi            R
           RR
          RRR
         RRRR
PPPPcccccOOOO
 PPPccccccOOO
  PPcccccccOO
   PccccccccO
    ccccccccc
w    ccccccccc
   PccccccccO
  PPcccccccOO
 PPPccccccOOO
PPPPcccccOOOO
         RRRR
          RRR
           RR
i            R
==============================
qi            G
           GG
          GGG
         GGGG
BBBBcccccYYYY
 BBBccccccYYY
  BBcccccccYY
   BccccccccY
    ccccccccc
w    ccccccccc
   PccccccccO
  PPcccccccOO
 PPPccccccOOO
PPPPcccccOOOO
         RRRR
          RRR
           RR
i            R
==============================
            G
           G G
          G G G
         G G G G
B B B B . . . . . Y Y Y Y
 B B B . . . . . . Y Y Y
  B B . . . . . . . Y Y
   B . . . . . . . . Y
    . . . . . . . . .
   P . . . . . . . . O
  P P . . . . . . . O O
 P P P . . . . . . O O O
P P P P . . . . . O O O O
         R R R R
          R R R
           R R
            R

JavaScript ( ES6 ) 228

Construcción línea por línea. Increíblemente largo en comparación con @ Sp3000 que hace lo mismo.

Usando la cadena de plantilla para guardar 3 bytes más para las nuevas líneas. Todas las nuevas líneas son significativas y contadas.

f=w=>(i=>{r=(n,s=b=' ')=>s.repeat(n),l=c=>(c='GBYPOR'[c])+r(i,b+c),t=n=>r(w*3-i)+l(n)+`
`,s=n=>r(w-1-i)+l(n)+b+r(w+w-i,'. ')+l(n+1)+`
`;for(o='',q=r(w)+r(w+w,'. ')+`.
`;++i<w;o+=t(0))q+=s(3);for(;i--;o+=s(1))q+=t(5)})(-1)||o+q

// LESS GOLFED

u=w=>{
  r =(n,s=b=' ') => s.repeat(n),
  l = c => (c='GBYPOR'[c])+r(i, b+c),
  t = n => r(w*3-i) + l(n) + '\n',
  s = n => r(w-1-i) + l(n) + b + r(w+w-i,'. ') + l(n+1) + '\n',
  o = '',
  q = r(w) + r(w+w,'. ') + '.\n';
  for(i=0; i<w; i++)
    o += t(0), q += s(3);  
  for(;i--;)
    o += s(1), q += t(5);
  return o+q
}  

go=()=> O.innerHTML=f(I.value|0)

go()

<input id=I value=5><button onclick='go()'>-></button><br>
<pre id=O></pre>