Das Spiel der chinesischen Kontrolleure wird auf einem Brett mit Feldern in Form eines sechszackigen Sterns gespielt:

^{Bild aus Wikipedia}

Wir können eine ASCII-artige Darstellung dieser Tafel erstellen, indem wir .für leere Stellen und die Buchstaben GYORPBfür die sechs farbigen Startpositionen verwenden:

            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

Um es interessanter zu machen, können wir auch die Größe ändern. Wir messen die Größe eines Brettes an der Seitenlänge seiner dreieckigen Startpositionen: Das Brett darüber hat die Größe 4.

Da es wirklich mühsam ist, all das von Hand zu tippen, schreiben wir ein Programm (oder eine Funktion), um es zu tun!

Einzelheiten

Ihr Code sollte über STDIN, ARGV oder ein Funktionsargument eine positive Ganzzahl annehmen, die die Größe der Karte darstellt. Geben Sie das Schachbrettmuster an STDOUT aus (Sie können es alternativ als Zeichenfolge zurückgeben, wenn Ihre Übermittlung eine Funktion ist).

Ausgabe muss entweder

• haben überhaupt keine nachgestellten Leerzeichen, oder
• genau genug nachgestellte Leerzeichen haben, um das Muster zu einem perfekten Rechteck der Breite 6 * N + 1 auszufüllen .

Die Ausgabe kann optional eine nachgestellte Newline enthalten. Es sind keine weiteren zusätzlichen (führenden, nachgestellten) Leerzeichen zulässig.

Beispiele

Größe 1:

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

Größe 2:

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

Größe 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

Wertung

Das ist Code-Golf : Der kürzeste Code in Bytes gewinnt.

Ruby, 141, 127

Gibt eine rechteckige Zeichenfolge zurück

->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 im Testprogramm

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]

Nicht so toll, aber hier ist mein erstes Gebot.

Die Whitespace-Regeln haben viele Bytes hinzugefügt. Zum Vergleich: Hier ist ein 120-Byte-Python-3-Programm, das nur visuell korrekt ist und nicht den Whitespace-Regeln folgt:

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)

Und hier ist mein etwas längerer rekursiver 149-Byte-Python-3-Versuch:

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

Dies ist im Nachhinein der falsche Ansatz für Python, aber ich poste ihn hier, falls jemand davon Gebrauch machen kann. Anstatt dieses Durcheinander von Code zu erklären, versuche ich, die Idee dahinter zu formulieren.

Die Idee ist, Dreieckskoordinaten zu verwenden , bei denen das Dreiecksgitter ganzzahligen Tripeln (a,b,c)mit entspricht a+b+c=0.

(Hier werden die Gitterpunkte als Sechsecke gezeichnet.)

Wir können kartesische Koordinaten in dreieckige umwandeln

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

Beachten Sie, dass xund ymuss die gleiche Parität haben, sonst ist es off-checkerboard und wir sollten ein Leerzeichen drucken.

In Dreieckskoordinaten weisen die Begrenzungslinien des sechsseitigen Stern Gleichungen: a==n, b==n, c==n, a==-n, b==-n, c==-n.

So können wir feststellen, in welcher Region wir uns [a,b,c,-a,-b,-c]befinden und welche größer sind als n.

• Wenn dies nicht der Fall ist, sind wir in der Mitte und drucken einen Punkt.
• Wenn genau eins ist, befinden wir uns in einem der sechs äußeren Dreiecke und drucken den Buchstaben aus, der dem Index entspricht.
• Wenn zwei oder mehr sind, sind wir außerhalb der Tafel und drucken ein Leerzeichen.

Das umgebende Rechteck verlangt, dass wir dies xim geschlossenen Intervall [-2 * n, 2 * n] und yim geschlossenen Intervall [-3 * n, 3 * n] tun .

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

Nimmt unäre Eingaben auf.

Jede Zeile sollte in eine eigene Datei #verschoben und in der Datei in eine neue Zeile geändert werden. Dies ist unpraktisch, aber Sie können den Code so wie er ist als eine Datei mit dem -sFlag #ausführen , die Markierungen beibehalten und sie möglicherweise in der Ausgabe in Zeilenumbrüche ändern, um die Lesbarkeit zu erhöhen.

Der Code hat eine minimale reguläre Komplexität. Die Hauptschritte in der Generation sind die folgenden:

• Erstellen Sie die letzte Gund die erste B.YZeile (begrenzt durch Markierungen ijkund tatsächlich verwendete Buchstaben sind RPO).
• Dupliziere die oberste GZeile mit einem Pluszeichen minus einem G, bis es nur noch ein G gibt.
• Dupliziere die unterste B.YZeile mit einem Pluszeichen und einem Punkt minus einem Bund Ybis es kein Bund Yübrig gibt.
• Kopieren Sie alle Zeilen in umgekehrter Reihenfolge nach dem aktuellen String (mit Hilfe des Markers q). Wir halten einen Marker ( w) in der Mitte.
• Wir ändern die Buchstaben RPOauf, GBYwenn sie vor dem Marker stehen.
• Fügen Sie die fehlenden Zwischenräume hinzu.

Die Ergebnisse nach jedem der obigen Punkte (getrennt durch ='s) für die Eingabe 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

Aufbau Zeile für Zeile. Unglaublich lang im Vergleich zu @ Sp3000, das macht das gleiche.

Verwenden der Vorlagenzeichenfolge, um 3 weitere Bytes für Zeilenumbrüche zu speichern. Alle Zeilenumbrüche sind signifikant und werden gezählt.

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>