Il gioco delle pedine cinesi si gioca su una tavola con spazi a forma di stella a sei punte:

^{Immagine da Wikipedia}

Possiamo creare una rappresentazione in arte ASCII di questa scheda, usando .per i punti vuoti e le lettere GYORPBper le sei posizioni di partenza colorate:

            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

Per renderlo più interessante, possiamo anche cambiare la dimensione. Misureremo le dimensioni di una tavola in base alla lunghezza laterale delle sue posizioni triangolari di partenza: la tavola sopra è la dimensione 4.

Dato che è davvero una seccatura scrivere tutto ciò a mano, scriviamo un programma (o una funzione) per farlo!

Dettagli

Il codice deve assumere un numero intero positivo che rappresenti la dimensione della scheda, tramite STDIN, ARGV o argomento della funzione. Emetti il ​​motivo a scacchiera su STDOUT (puoi alternativamente restituirlo come stringa se il tuo invio è una funzione).

L'output deve essere

• non ha affatto spazi finali, o
• avere spazi trailing esattamente sufficienti per riempire il modello in un rettangolo perfetto di larghezza 6 * N + 1.

L'output può facoltativamente avere una nuova riga finale. Non sono consentiti altri spazi extra (iniziali, finali).

Esempi

Taglia 1:

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

Taglia 2:

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

Taglia 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

punteggio

Questo è code-golf : vince il codice più breve in byte.

Ruby, 141 127

Restituisce una stringa rettangolare

->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 registrato nel programma di 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 byte

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]

Non eccezionale, ma ecco la mia offerta iniziale.

Le regole degli spazi bianchi hanno aggiunto molti byte. Per fare un confronto, ecco un programma Python 3 da 120 byte che è solo visivamente corretto e non segue le regole degli spazi bianchi:

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)

Ed ecco il mio tentativo Python 3 a 149 byte leggermente più lungo ricorsivo:

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

Questo è, a posteriori, l'approccio sbagliato per Python, ma lo sto postando qui nel caso in cui qualcuno possa farne uso. Piuttosto che spiegare questo casino di codice, proverò a dire l'idea alla base.

L'idea è quella di utilizzare coordinate triangolari , in cui il reticolo triangolare corrisponde al numero intero triple (a,b,c)con a+b+c=0.

(Qui, i punti reticolari sono disegnati come esagoni.)

Possiamo convertire le coordinate cartesiane in triangolari come

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

notandolo xe ydeve avere la stessa parità, altrimenti è fuori dalla scacchiera e dovremmo stampare uno spazio.

In coordinate triangolari, le linee di delimitazione della stella a sei facce hanno equazioni: a==n, b==n, c==n, a==-n, b==-n, c==-n.

Quindi, possiamo determinare in quale regione ci troviamo di cui di cui [a,b,c,-a,-b,-c]sono maggiori n.

• Se nessuno lo è, siamo al centro e stampiamo un punto.
• Se esattamente lo è, siamo in uno dei sei triangoli esterni e stampiamo la lettera corrispondente all'indice.
• Se due o più sono, siamo fuori dal tabellone e stampiamo uno spazio.

Il rettangolo di delimitazione richiede che lo facciamo xnell'intervallo chiuso [-2 * n, 2 * n] e ynell'intervallo chiuso [-3 * n, 3 * n].

Retina , 234 byte

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

Riceve input in unario.

Ogni riga dovrebbe andare nel proprio file e #dovrebbe essere cambiata in newline nel file. Ciò non è pratico, ma è possibile eseguire il codice come in un unico file con il -sflag, mantenendo i #marker e modificandoli in newline nell'output per leggibilità, se lo si desidera.

Il codice ha una complessità regex minima. I passaggi principali della generazione sono i seguenti:

• Crea l'ultima Griga e la prima B.Yriga (sono delimitate da marcatori ijke le lettere effettive utilizzate RPO).
• Duplica la Glinea più in alto con uno spazio positivo, meno una G fino a quando c'è solo una G.
• Duplica la B.Ylinea di fondo con uno spazio e un punto più, meno una Be Yfino a quando non ci sono Be Yrimangono.
• Copia tutte le righe in ordine inverso dopo la stringa corrente (con l'aiuto del marcatore q). Manteniamo un marker ( w) nel mezzo.
• Cambiamo le lettere RPOin GBYse sono prima del marcatore.
• Aggiungi gli spazi intermedi mancanti.

I risultati dopo ciascuno dei punti sopra (delimitati da ='s) per l'input 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

Costruzione riga per riga. Incredibilmente lungo rispetto a @ Sp3000 che fa lo stesso.

Utilizzo della stringa di modello per salvare altri 3 byte per le nuove righe. Tutte le nuove linee sono significative e contate.

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>