Le jeu des dames chinoises se joue sur un plateau avec des espaces en forme d'étoile à six branches:

^{Image de Wikipedia}

Nous pouvons créer une représentation ASCII de cette carte, en utilisant .pour les emplacements vides et les lettres GYORPBpour les six emplacements de départ colorés:

            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

Pour le rendre plus intéressant, nous pouvons également changer la taille. Nous mesurerons la taille d'une planche par la longueur latérale de ses emplacements de départ triangulaires: la planche ci-dessus est de taille 4.

Puisqu'il est vraiment difficile de taper tout cela à la main, écrivons un programme (ou une fonction) pour le faire!

Détails

Votre code doit prendre un entier positif représentant la taille de la carte, via STDIN, ARGV ou un argument de fonction. Sortez le motif en damier sur STDOUT (vous pouvez alternativement le renvoyer sous forme de chaîne si votre soumission est une fonction).

La sortie doit soit

• n'ont aucun espace de fin, ou
• avoir exactement suffisamment d'espaces de fin pour remplir le motif en un rectangle parfait de largeur 6 * N + 1.

La sortie peut éventuellement avoir une nouvelle ligne de fin. Aucun autre espace supplémentaire (avant, arrière) n'est autorisé.

Exemples

Taille 1:

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

Taille 2:

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

Taille 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

Notation

C'est le code-golf : le code le plus court en octets gagne.

Rubis, 141 127

Renvoie une chaîne rectangulaire

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

Non testé dans le programme de test

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 octets

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]

Pas génial, mais voici mon offre initiale.

Les règles d'espaces blancs ont ajouté beaucoup d'octets. À titre de comparaison, voici un programme Python 3 de 120 octets qui n'est correct que visuellement et ne suit pas les règles des espaces blancs:

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)

Et voici ma tentative Python 3 récursive légèrement plus longue de 149 octets:

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

C'est, rétrospectivement, la mauvaise approche pour Python, mais je le poste ici au cas où quelqu'un pourrait s'en servir. Plutôt que d'expliquer ce désordre de code, je vais essayer de dire l'idée derrière cela.

L'idée est d'utiliser des coordonnées triangulaires , dans lesquelles le réseau triangulaire correspond à des triplets entiers (a,b,c)avec a+b+c=0.

(Ici, les points du réseau sont dessinés sous forme d'hexagones.)

Nous pouvons convertir des coordonnées cartésiennes en coordonnées triangulaires comme

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

notant cela xet ydoit avoir la même parité, ou sinon c'est hors-damier et nous devrions imprimer un espace.

En coordonnées triangulaires, les lignes de délimitation de l'étoile à six côtés ont des équations: a==n, b==n, c==n, a==-n, b==-n, c==-n.

Ainsi, nous pouvons déterminer dans quelle région nous nous trouvons, par laquelle [a,b,c,-a,-b,-c]sont supérieures à n.

• S'il n'y en a pas, nous sommes au centre et imprimons un point.
• Si exactement un est, nous sommes dans l'un des six triangles extérieurs et imprimons la lettre correspondant à l'index.
• Si deux ou plus le sont, nous sommes en dehors du tableau et imprimons un espace.

Le rectangle englobant exige que nous le fassions pour xdans l'intervalle fermé [-2 * n, 2 * n] et ydans l'intervalle fermé [-3 * n, 3 * n].

Rétine , 234 octets

.
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
.
 #
#

Prend entrée en unaire.

Chaque ligne doit aller dans son propre fichier et #doit être remplacée par une nouvelle ligne dans le fichier. Cela n'est pas pratique, mais vous pouvez exécuter le code tel quel en un seul fichier avec l' -sindicateur, en conservant les #marqueurs et peut-être en les changeant en sauts de ligne pour la lisibilité si vous le souhaitez.

Le code a une complexité regex minimale. Les principales étapes de la génération sont les suivantes:

• Créez la dernière Gligne et la première B.Yligne (délimitées par des marqueurs ijket les lettres réellement utilisées le sont RPO).
• Dupliquez la Gligne du haut avec un espace plus, moins un G jusqu'à ce qu'il n'y ait qu'un seul G.
• Dupliquez la B.Yligne du bas avec un espace plus et un point, moins a Bet Yjusqu'à ce qu'il n'y en ait pas Bet à Ygauche.
• Copiez toutes les lignes dans l'ordre inverse après la chaîne actuelle (à l'aide du marqueur q). Nous gardons un marqueur ( w) au milieu.
• Nous changeons les lettres RPOà GBYsi elles sont avant le marqueur.
• Ajoutez les espaces intermédiaires manquants.

Les résultats après chacun des points ci-dessus (délimités par =des) pour l'entrée 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

Construction ligne par ligne. Incroyablement long par rapport à @ Sp3000 qui fait de même.

Utilisation de la chaîne de modèle pour enregistrer 3 octets supplémentaires pour les retours à la ligne. Toutes les nouvelles lignes sont importantes et comptées.

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>