Las teselaciones hexagonales , o las inclinaciones del avión, son de tres colores, lo que significa que usando solo tres colores, como Rojo, Azul y Verde, cada hexágono puede ser coloreado sin dos hexágonos que compartan un borde que comparta un color. Un ejemplo parcial que muestra tal patrón.

Dado un mosaico hexagonal parcial en ASCII (a través de STDIN, leyendo desde un archivo, etc.), cambie los colores de los caracteres (a través de códigos ANSI, manipulación de imágenes, etc.) para adaptarse a este color. El giro es el centro de los hexágonos (los *siguientes son los tres colores, y las líneas intermedias deben ser una mezcla de sus dos *colores correspondientes . Si la línea está en el borde exterior, debe coincidir con la correspondiente *.

Por ejemplo, dado el mosaico hexagonal parcial de

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

supongamos que decidimos colorear el hexágono superior izquierdo *para que sea Rojo, y sus dos vecinos sean Azul y Verde (en sentido horario). Entonces la |línea debe ser magenta y la /línea debe ser amarilla. Si seguimos coloreando, eventualmente terminaremos con algo como esto (ampliado para mayor claridad):

O, para una entrada de

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

puede colorearlo así (ampliado para mayor claridad):

Algunos casos de prueba adicionales (su código debería poder manejarlos):

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


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



 / \
| * |
 \ /

Reglas

• Se garantiza que la entrada tendrá al menos un hexágono, y ninguna entrada tendrá un "agujero".
• No necesita comenzar a colorear con rojo, siempre que mantenga la regla de los tres colores.
• Si el mosaico parcial puede ser de dos colores, puede hacerlo sin penalización (como en el segundo ejemplo); no necesariamente necesita extrapolar el mosaico parcial a un mosaico completo.
• Los centros del hexágono *deben estar coloreados con rojo, azul o verde, mientras que las líneas intermedias deben ser cian, amarillo o magenta. Por ejemplo, habiendo un Magenta *no está permitido, y una Red |o \o /debe estar en el borde exterior del dibujo. Ver colores , a continuación.
• Si su consola no tiene estos colores exactos, utilice la aproximación más cercana y especifique en su respuesta qué aproximación está utilizando.
• Los espacios en blanco iniciales o finales, incluidas las nuevas líneas finales, son aceptables siempre que los caracteres se alineen.
• El mosaico parcial se puede ingresar con espacio para formar un rectángulo, si eso facilita su código.
• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• La salida puede ser a la consola, guardada como una imagen, etc.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Colores y mezclas de colores:

Los tres colores base disponibles son (con códigos de color en formato decimal RGB):

• rojo (255,0,0)
• Verde (0,255,0)
• Azul (0,0,255)

Las combinaciones son:

• Rojo y verde se combinan para hacer amarillo (255,255,0)
• Azul y verde se combinan para hacer cian (0,255,255)
• El rojo y el azul se combinan para hacer magenta (255,0,255)

JavaScript (ES6), 219 203 201 bytes

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>

Explicación: cada personaje está envuelto en una fontetiqueta para establecer su color, que se calcula marcando cada cuadrado, más los cuadrados dos a la izquierda y a la derecha, más los cuatro cuadrados uno en diagonal, para *sy si es así combinando los colores de todos *s encontrado. Los *colores se eligen simplemente tomando su módulo de coordenadas horizontales 3 y cambiando una máscara de bits adecuadamente. Editar: Guardado 2 bytes cambiando de #RRGGBBa #RGBcolores.

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

Similar a mi enfoque de lienzo ; localiza todos los *s en la cadena de entrada y escribe hexágonos en la página en forma de <pre>elementos posicionados absolutamente . Como mix-blend-modese establece en lighten, la adición de color se realiza automáticamente cuando los caracteres se superponen.

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

Pruébalo en línea!

¡Golf y arreglado gracias a user202729!
-27 bytes gracias al Sr. Xcoder
-24 bytes gracias a 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

Pruébalo en línea!

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

Localiza todos los *s en la cadena de entrada y pinta un hexágono ASCII en el lienzo en las posiciones correspondientes. Porque globalCompositeOperation='lighter', la adición de color se realiza automáticamente cuando los caracteres se superponen.

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

Se scale()agregaron un multiplicador y un comando adicional al fragmento para mayor visibilidad.

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

También vea mi enfoque basado en CSS .

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

En formato de código ligeramente más ordenado:

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

La entrada se toma como una matriz 2D, como ingresar lo siguiente cuando se le solicita la entrada:

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

MATLAB, hasta donde yo sé, no tiene la capacidad de generar colores en la consola (a excepción de los trucos sucios de Java que estoy descontando). Como tal, el resultado se imprime en una figura.

La coloración se logra al encontrar la ubicación de todos *en la entrada, y luego, en una matriz de colores RGB ( p), se escribe un recuadro 5x3 de 1 (255 en representación de color MATLAB) centrado sobre el *. El cuadro se escribe en el color correspondiente con el índice mod-3 a lo largo de cada línea, y las líneas pares tienen el índice de color desplazado por un desplazamiento.

Esto produce una matriz de color donde cualquier cuadro que se superponga dará como resultado el color mixto requerido. El ejemplo anterior produce la siguiente matriz de color.

Las regiones blanca y negra son irrelevantes porque en esas ubicaciones se imprime un espacio, lo que significa que en realidad no vemos el color incorrecto.

Una vez que se crea la matriz de color, mostramos cada carácter en una figura usando el textcomando, configurando el color del texto a la entrada correspondiente en la matriz de color. El ejemplo anterior mostrará: