Le tessellazioni esagonali o i tasselli del piano sono tricolore, il che significa che utilizzando solo tre colori, come rosso, blu e verde, ogni esagono può essere colorato senza due esagoni che condividono un bordo che condivide un colore. Un esempio parziale che mostra tale modello.

Data una piastrellatura esagonale parziale in ASCII (tramite STDIN, lettura da un file, ecc.), Cambia i colori dei personaggi (tramite codici ANSI, manipolazione delle immagini, ecc.) Per adattarli a questa colorazione. La torsione è al centro degli esagoni (i *, sotto) sono i tre colori, e le linee tra le due devono essere un mix dei loro due corrispondenti *colori dell'esagono . Se la linea si trova sul bordo esterno, dovrebbe corrispondere alla corrispondente *.

Ad esempio, data la piastrellatura esagonale parziale di

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

supponiamo che decidiamo di colorare l'esagono *in alto a sinistra in rosso, e i suoi due vicini in blu e verde (in senso orario). Quindi la |linea deve essere magenta e la /linea deve essere gialla. Se continuiamo a colorare, finiremo con qualcosa del genere (ingrandito per chiarezza):

Oppure, per un input di

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

potresti colorarlo in questo modo (ingrandito per chiarezza):

Alcuni casi di test aggiuntivi (il tuo codice dovrebbe essere in grado di gestirli):

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


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



 / \
| * |
 \ /

Regole

• È garantito che l'input abbia almeno un esagono e nessun input avrà un "foro".
• Non è necessario iniziare la colorazione con il rosso, purché si mantenga la regola dei tre colori.
• Se la piastrellatura parziale può essere bicolore, è possibile farlo senza penalità (come nel secondo esempio) - non è necessario estrapolare la piastrellatura parziale su una piastrellatura completa.
• I centri esagonali *devono essere colorati con rosso, blu o verde, mentre le linee tra devono essere ciano, giallo o magenta. Ad esempio, *non è consentito avere un magenta e un rosso |o \o /deve trovarsi sul bordo esterno del disegno. Vedi colori , sotto.
• Se la tua console non ha questi colori esatti, utilizza l'approssimazione più vicina e specifica nella risposta quale approssimazione stai utilizzando.
• Gli spazi bianchi iniziali o finali, comprese le nuove righe finali, sono accettabili purché i personaggi siano allineati.
• La piastrellatura parziale può essere inserita con spaziatura spaziale per formare un rettangolo, se ciò semplifica il codice.
• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• L'output può essere sulla console, salvato come immagine, ecc.
• Sono vietate le scappatoie standard .
• Si tratta di code-golf, quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Colori e miscele di colore:

I tre colori di base disponibili sono (con codici colore in formato decimale RGB):

• Rosso (255,0,0)
• verde (0,255,0)
• Blu (0,0,255)

Le combinazioni sono:

• Il rosso e il verde si combinano per rendere giallo (255,255,0)
• Blu e verde si combinano per rendere il ciano (0,255,255)
• Il rosso e il blu si combinano per creare il 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>

Spiegazione: Ogni carattere è racchiuso in un fonttag per impostare il suo colore, che viene calcolato controllando ogni quadrato, più i due quadrati a sinistra e a destra, più i quattro quadrati uno in diagonale uno alla volta, per *se combinando i colori di tutti *trovato. I *colori sono scelti semplicemente prendendo la loro coordinata orizzontale modulo 3 e spostando una maschera di bit in modo appropriato. Modifica: salvato 2 byte passando da #RRGGBBa #RGBcolori.

JavaScript (ES6), 210 byte (usando HTML + CSS)

Simile al mio approccio alla tela ; individua tutte le *s nella stringa di input e scrive esagoni nella pagina sotto forma di <pre>elementi assolutamente posizionati . Poiché mix-blend-modeè impostato su lighten, l'aggiunta di colore viene eseguita automaticamente quando i caratteri si sovrappongono.

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 byte

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

Provalo online!

Golfato e riparato grazie a user202729!
-27 byte grazie a Mr. Xcoder
-24 byte grazie a Jonathan Frech

Python 2 , 346 331 byte

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

Provalo online!

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

Individua tutte le *s nella stringa di input e dipinge un esagono ASCII sulla tela nelle posizioni corrispondenti. Perché globalCompositeOperation='lighter', l'aggiunta di colore viene eseguita automaticamente quando i caratteri si sovrappongono.

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

Un moltiplicatore e un scale()comando aggiuntivo sono stati aggiunti allo snippet per la visibilità.

// 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>

Vedi anche il mio approccio basato su CSS .

MATLAB / Octave , 223 byte

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

In formato codice leggermente più ordinato:

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

L'input viene considerato come un array 2D, ad esempio immettendo quanto segue quando richiesto per l'input:

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

MATLAB, per quanto ne so, non ha la capacità di produrre colori sulla console (ad eccezione degli hack Java sporchi che sto scontando). Pertanto, l'output viene invece stampato su una figura.

La colorazione si ottiene trovando la posizione di tutti *nell'input, e quindi in una matrice di colori RGB ( p), una casella 5x3 di 1 (255 nella rappresentazione del colore MATLAB) è scritta centrata attorno al *. La casella è scritta nel colore corrispondente all'indice mod-3 lungo ciascuna riga, con le linee pari con l'indice del colore spostato di un offset.

Questo produce una matrice di colori in cui le caselle che si sovrappongono daranno il colore misto richiesto. L'esempio sopra produce la seguente matrice di colori.

Le regioni bianche e nere sono irrilevanti perché in quelle posizioni viene stampato uno spazio nel senso che in realtà non vediamo il colore errato.

Una volta creata la matrice dei colori, visualizziamo ogni carattere su una figura usando il textcomando, impostando il colore del testo sulla voce corrispondente nella matrice dei colori. L'esempio sopra mostrerà: