O jogo de damas chinesas é jogado em um tabuleiro com espaços na forma de uma estrela de seis pontas:

^{Imagem da Wikipedia}

Podemos criar uma representação em ASCII deste quadro, usando .pontos vazios e as letras GYORPBdos seis locais iniciais coloridos:

            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 torná-lo mais interessante, também podemos alterar o tamanho. Mediremos o tamanho de uma placa pelo comprimento lateral de seus locais de partida triangulares: a placa acima é do tamanho 4.

Como é realmente difícil digitar tudo isso à mão, vamos escrever um programa (ou função) para fazer isso!

Detalhes

Seu código deve ter um número inteiro positivo representando o tamanho do quadro, via STDIN, ARGV ou argumento de função. Envie o padrão quadriculado para STDOUT (você pode retorná-lo como uma sequência alternadamente, se o envio for uma função).

A saída deve

• não tem espaços à direita, ou
• tenha espaços à direita exatamente o suficiente para preencher o padrão em um retângulo perfeito de largura 6 * N + 1.

A saída pode opcionalmente ter uma nova linha à direita. Nenhum outro espaço em branco extra (à esquerda, à direita) é permitido.

Exemplos

Tamanho 1:

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

Tamanho 2:

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

Tamanho 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

Pontuação

Este é o código-golfe : o código mais curto em bytes vence.

Ruby, 141 127

Retorna uma string retangular

->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)}*$/}

Ungolfed in program program

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]

Não é ótimo, mas aqui está o meu lance inicial.

As regras de espaço em branco adicionavam muitos bytes. Para comparação, aqui está um programa Python 3 de 120 bytes, que só está correto visualmente e não segue as regras de espaço em branco:

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)

E aqui está minha tentativa Python 3 recursiva de 149 bytes, um pouco mais longa:

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

Python 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

Esta é, em retrospecto, a abordagem errada para o Python, mas estou postando aqui caso alguém possa usá-lo. Em vez de explicar essa bagunça de código, tentarei dizer a idéia por trás disso.

A ideia é a utilização de coordenadas triangulares , em que a estrutura triangular corresponde ao número inteiro triplos (a,b,c)com a+b+c=0.

(Aqui, os pontos da treliça são desenhados como hexágonos.)

Podemos converter coordenadas cartesianas em triangulares como

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

observando isso xe ydeve ter a mesma paridade; caso contrário, não é quadriculado e devemos imprimir um espaço.

Em coordenadas triangulares, as linhas delimitadoras da estrela de seis lados têm equações: a==n, b==n, c==n, a==-n, b==-n, c==-n.

Assim, podemos determinar em que região estamos e por que [a,b,c,-a,-b,-c]são maiores que n.

• Se não houver, estamos no centro e imprimimos um ponto.
• Se exatamente um for, estamos em um dos seis triângulos externos e imprima a letra correspondente ao índice.
• Se dois ou mais, estamos fora do quadro e imprimimos um espaço.

O retângulo delimitador exige que façamos isso xno intervalo fechado [-2 * n, 2 * n] e yno intervalo fechado [-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
.
 #
#

Recebe entrada em unário.

Cada linha deve ir para seu próprio arquivo e #deve ser alterada para nova linha no arquivo. Isso é impraticável, mas você pode executar o código como um arquivo com a -sbandeira, mantendo os #marcadores e talvez alterando-os para novas linhas na saída para facilitar a leitura, se desejar.

O código possui complexidade de regex mínima. As principais etapas da geração são as seguintes:

• Crie a última Glinha e a primeira B.Ylinha (delimitadas por marcadores ijke letetrs reais usados RPO).
• Duplique a Glinha superior com um espaço positivo, menos um G até que haja apenas um G.
• Duplicar o fundo B.Ylinha com um espaço de mais e ponto, menos um Be Yaté que não haja Be Yesquerda.
• Copie todas as linhas na ordem inversa após a sequência atual (com a ajuda do marcador q). Mantemos um marcador ( w) no meio.
• Mudamos as letras RPOpara GBYse estiverem antes do marcador.
• Adicione os espaços intermediários ausentes.

Os resultados após cada um dos pontos acima (delimitados por ='s) para a 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

Construção linha por linha. Incrivelmente longo comparado ao @ Sp3000 que faz o mesmo.

Usando a sequência de modelos para salvar mais 3 bytes para novas linhas. Todas as novas linhas são significativas e 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>