Sechseckige Tessellationen oder Kacheln der Ebene sind dreifarbig. Das bedeutet, dass mit nur drei Farben wie Rot, Blau und Grün jedes Sechseck gefärbt werden kann, ohne dass zwei Sechsecke eine Farbe gemeinsam haben. Ein Teilbeispiel, das ein solches Muster zeigt.

Ändern Sie bei einer teilweisen hexagonalen Kachelung in ASCII (über STDIN, Lesen aus einer Datei usw.) die Farben der Zeichen (über ANSI-Codes, Bildmanipulation usw.), um sie an diese Farbgebung anzupassen. Die Verdrehung ist die Mitte der Sechsecke (die *, unten) sind die drei Farben, und die Linien zwischen müssen eine Mischung aus den *Farben der beiden entsprechenden Sechsecke sein . Befindet sich die Linie am äußeren Rand, sollte sie mit der entsprechenden übereinstimmen *.

Zum Beispiel angesichts der teilweisen hexagonalen Kacheln von

 / \ / \ / \ / \
| * | * | * | * |
 \ / \ / \ / \ /
  | * | * | * |
   \ / \ / \ /

Nehmen wir an, wir färben das linke obere Feld *rot und die beiden Nachbarn blau und grün (im Uhrzeigersinn). Dann muss die |Linie Magenta und die /Linie Gelb sein. Wenn wir weiter färben, erhalten wir irgendwann so etwas (der Klarheit halber vergrößert):

Oder für eine Eingabe von

     / \
    | * |
   / \ /
  | * |
 / \ /
| * |
 \ /

Sie könnten es so einfärben (zur Verdeutlichung vergrößert):

Einige zusätzliche Testfälle (Ihr Code sollte in der Lage sein, diese zu verarbeiten):

 / \ / \
| * | * |
 \ / \ /
  | * |
 / \ / \
| * | * |
 \ / \ /


 / \
| * |
 \ / \
  | * |
 / \ /
| * |
 \ /



 / \
| * |
 \ /

Regeln

• Der Eingang hat garantiert mindestens ein Sechseck und kein Eingang hat ein "Loch".
• Sie müssen Ihre Färbung nicht mit Rot beginnen, solange Sie die Dreifarbenregel einhalten.
• Wenn die teilweise Kachelung zweifarbig sein kann, können Sie dies ohne Nachteile tun (wie im zweiten Beispiel) - Sie müssen die teilweise Kachelung nicht unbedingt auf eine vollständige Kachelung extrapolieren.
• Die Sechskantmitten *müssen entweder rot, blau oder grün gefärbt sein, während die Linien zwischen Cyan, Gelb oder Magenta sein müssen. Ein Magenta *ist beispielsweise nicht zulässig, und ein Rot |oder \oder /muss sich am äußeren Rand der Zeichnung befinden. Siehe Farben unten.
• Wenn Ihre Konsole nicht über genau diese Farben verfügt, verwenden Sie bitte die genaueste Annäherung und geben Sie in Ihrer Antwort an, welche Annäherung Sie verwenden.
• Führende oder nachfolgende Leerzeichen, einschließlich nachfolgender Zeilenumbrüche, sind zulässig, solange die Zeichen in einer Reihe stehen.
• Die teilweise Kachelung kann mit Leerzeichen als Rechteck eingegeben werden, wenn dies für Ihren Code einfacher ist.
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Die Ausgabe kann auf der Konsole erfolgen, als Bild usw. gespeichert werden.
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Farben und Farbmischungen:

Die drei verfügbaren Grundfarben sind (mit Farbcodes im RGB-Dezimalformat):

• rot (255,0,0)
• Grün (0,255,0)
• Blau (0,0,255)

Die Kombinationen sind:

• Rot und Grün ergeben zusammen Gelb (255,255,0)
• Blau und Grün ergeben zusammen Cyan (0,255,255)
• Rot und Blau ergeben zusammen Magenta (255,0,255)

JavaScript (ES6), 219 203 201 Byte

f=
s=>s.split`
`.map((b,i,a)=>b.replace(/./g,(c,j)=>`<font color=#${g=(x,y)=>((a[x+i]||``)[b=y+j]==`*`&&15<<b%3*4)|(y<0?8<<9:g(x,y-2)),(g(0,2)|g(-1,1)|g(1,1)).toString(16).slice(1)}>${c}</font>`)).join`
`

<input type=button value="Colourise!" onclick=i.innerHTML=f(i.textContent)>
<pre id=i contenteditable> / \ / \
| * | * |
 \ / \ / \
  | * | * |
 / \ / \ / \
| * |   | * |
 \ / \ / \ / \
  | * | * | * |
 / \ / \ / \ /
| * | * |
 \ / \ /</pre>

Erläuterung: Jedes Zeichen wird in ein fontTag eingehüllt , um seine Farbe festzulegen. Diese wird berechnet, indem jedes Quadrat sowie die Quadrate zwei links und rechts und die vier Quadrate eins diagonal entfernt für *s angekreuzt werden. Wenn dies der Fall ist, werden die Farben aller Quadrate kombiniert *s gefunden. Die *Farben werden einfach ausgewählt, indem ihr horizontales Koordinatenmodul 3 genommen und eine Bitmaske entsprechend verschoben wird. Bearbeiten: 2 Bytes durch Umschalten #RRGGBBauf #RGBFarben gespeichert .

JavaScript (ES6), 210 Byte (unter Verwendung von HTML + CSS)

Ähnlich wie bei meinem Canvas-Ansatz ; Findet alle *s in der Eingabezeichenfolge und schreibt Sechsecke in Form absolut positionierter <pre>Elemente auf die Seite . Da auf eingestellt mix-blend-modeist lighten, wird das Hinzufügen von Farben automatisch ausgeführt, wenn sich Zeichen überlappen.

s=>s.split`
`.map((r,y)=>[...r].map((c,x)=>c=='*'&&document.write(`<pre style=position:fixed;mix-blend-mode:lighten;line-height:1;left:${x}ch;top:${y}em;color:${['red','lime','blue'][x%3]}> / \\
| * |
 \\ /`)))

f=

s=>s.split`
`.map((r,y)=>[...r].map((c,x)=>c=='*'&&document.write(`<pre style=position:fixed;mix-blend-mode:lighten;line-height:1;left:${x}ch;top:${y}em;color:${['red','lime','blue'][x%3]}> / \\
| * |
 \\ /`)))

f(` / \\ / \\ / \\ / \\
| * | * | * | * |
 \\ / \\ / \\ / \\ /
  | * | * | * |
   \\ / \\ / \\ /`)

Python 2 , 279 Bytes

e=enumerate
x=input()
c=[[i,j]for i,t in e(x)for j,_ in e(t)if"*"==x[i][j]]
C=[[j%3*([i,j]in c)for j,_ in e(o)]for i,o in e(x)]
for J,K in c:
	for i in-1,0,1:q=2-(i&1);_=C[i+J];_[K+q]=_[K-q]=_[K-q]|C[J][K]
for i,o in e(x):print"".join("[%dm"%(30+C[i][j])+x[i][j]for j,_ in e(o))

Probieren Sie es online!

Golfen und fixieren dank user202729!
-27 Bytes dank Mr. Xcoder
-24 Bytes dank Jonathan Frech

Python 2 , 346 331 Bytes

e=enumerate
C='0132645'
def f(s):
 c={(i,j):[1+(i/2%2+j/4)%3*2]for i,l in e(s)for j,x in e(l)if'*'==x}
 for i,l in e(s):
  r=''
  for j,x in e(l):a=c.get((i,j),c.get((i-(x<'|'),j+[-1,1][x>'/']+(x>'z')),[]))+c.get((i+(x<'|'),j+[1,-1][x>'/']-(x>'z')),[])if' '<x else[0];r+='\033[3'+C[[sum(a)/len(a),6][set(a)=={5,1}]]+'m'+x
  print r

Probieren Sie es online!

HTML (Canvas) + JavaScript (ES6), 13 + 251 = 264 Byte

Sucht alle *s in der Eingabezeichenfolge und zeichnet ein ASCII-Sechseck auf die Zeichenfläche an den entsprechenden Positionen. Weil das globalCompositeOperation='lighter'Hinzufügen von Farben automatisch erfolgt, wenn sich Zeichen überlappen.

HTML

<canvas id=c>

JavaScript

s=>{c.width=c.height=s.length
with(c.getContext`2d`)font='1px monospace',globalCompositeOperation='lighter',s.split`
`.map((r,y)=>[...r].map((c,x)=>c=='*'&&[` / \\`,`| * |`,` \\ /`].map((t,i)=>fillText(t,x,y+i),fillStyle=['red','lime','blue'][x%3])))}

Ein Multiplikator und ein zusätzlicher scale()Befehl wurden zur besseren Sichtbarkeit zum Snippet hinzugefügt.

// Unscaled
/*
f=
s=>{c.width=c.height=s.length
with(c.getContext`2d`)font='1px monospace',globalCompositeOperation='lighter',s.split`
`.map((r,y)=>[...r].map((c,x)=>c=='*'&&[` / \\`,`| * |`,` \\ /`].map((t,i)=>fillText(t,x,y+i),fillStyle=['red','lime','blue'][x%3])))}
*/


// Scaled
let scaleFactor = 40

f=
s=>{c.width=c.height=s.length*scaleFactor
with(c.getContext`2d`)scale(scaleFactor,scaleFactor),font='1px monospace',globalCompositeOperation='lighter',s.split`
`.map((r,y)=>[...r].map((c,x)=>c=='*'&&[` / \\`,`| * |`,` \\ /`].map((t,i)=>fillText(t,x,y+i),fillStyle=['red','lime','blue'][x%3])))}


// Test
f(` / \\ / \\ / \\ / \\
| * | * | * | * |
 \\ / \\ / \\ / \\ /
  | * | * | * |
   \\ / \\ / \\ /`)

<canvas id=c>

Siehe auch meinen CSS-basierten Ansatz .

MATLAB / Octave , 223 Bytes

a=input('')';s=size(a);p=zeros([s 3]);[i,j]=ind2sub(s,find(a=='*'));
for f=1:nnz(i)
p((-2:2)+i(f),(-1:1)+j(f),mod(f+~mod(j(f)/2,2),3)+1)=1;end
for f=1:nnz(a)
[i,j]=ind2sub(s,f);text(i/s(1),1-j/s(2),a(i,j),'Co',p(i,j,:));end

Im etwas übersichtlicheren Code-Format:

a=input('')';                  %Grab input as 2D array
s=size(a);                     %Get input size
p=zeros([s 3]);                %Make empty colour matrix of matching size with RGB
[i,j]=ind2sub(s,find(a=='*')); %Find all *'s
for f=1:nnz(i)                 %For each *
    %Fill a 5x3 box centred at the * on the colour channel for this box
    %Overlapping regions between boxes will result in the correct mix.
    p((-2:2)+i(f),(-1:1)+j(f),mod(f+~mod(j(f)/2,2),3)+1)=1;
end
%Display as text on a figure
for f=1:nnz(a)
    [i,j]=ind2sub(s,f);
    text(i/s(1),1-j/s(2),a(i,j),'Co',p(i,j,:))
end

Die Eingabe wird als 2D-Array verwendet. Geben Sie beispielsweise Folgendes ein, wenn Sie zur Eingabe aufgefordert werden:

[' / \ / \ / \ / \ ';'| * | * | * | * |';' \ / \ / \ / \ / ';'  | * | * | * |  ';'   \ / \ / \ /   ']

Soweit mir bekannt ist, kann MATLAB keine Farben auf der Konsole ausgeben (mit Ausnahme von schmutzigen Java-Hacks, die ich rabattiere). Als solches wird die Ausgabe stattdessen auf eine Figur gedruckt.

Die Färbung erfolgt durch Ermitteln der Position aller *Elemente in der Eingabe und anschließend in einem RGB-Farbfeld (p ) eine 5x3-Box mit Einsen (255 in MATLAB-Farbdarstellung) zentriert um das geschrieben *. Das Kästchen wird entlang jeder Zeile in die Farbe geschrieben, die dem Mod-3-Index entspricht, wobei bei geraden Zeilen der Farbindex um einen Versatz verschoben ist.

Dies erzeugt eine Farbmatrix, in der sich überlappende Kästchen die gewünschte Mischfarbe ergeben. Das obige Beispiel erzeugt die folgende Farbmatrix.

Die weißen und schwarzen Bereiche sind irrelevant, da an diesen Stellen ein Leerzeichen gedruckt wird, was bedeutet, dass wir die falsche Farbe nicht sehen.

Sobald die Farbmatrix erstellt ist, zeigen wir mit dem textBefehl jedes Zeichen auf einer Figur an und stellen die Farbe des Texts auf den entsprechenden Eintrag in der Farbmatrix ein. Das obige Beispiel zeigt: