Os mosaicos hexagonais , ou inclinações do avião, são tricolores - o que significa que, usando apenas três cores, como Vermelho, Azul e Verde, cada hexágono pode ser colorido sem dois hexágonos que compartilham uma borda que compartilha uma cor. Um exemplo parcial mostrando esse padrão.

Dada uma disposição hexagonal parcial em ASCII (via STDIN, leitura de um arquivo, etc.), altere as cores dos caracteres (via códigos ANSI, manipulação de imagem etc.) para ajustar-se a essa coloração. A torção é o meio dos hexágonos (as *abaixo) são as três cores, e as linhas entre elas precisam ser uma mistura das *cores correspondentes das duas hexágonos . Se a linha estiver na borda externa, ela deve corresponder à correspondente *.

Por exemplo, dada a telha hexagonal parcial de

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

suponha que decidimos colorir o hexágono superior esquerdo *para vermelho e seus dois vizinhos para azul e verde (no sentido horário). Então a |linha precisa ser magenta e a /linha precisa ser amarela. Se continuarmos colorindo, acabaremos com algo assim (ampliado para maior clareza):

Ou, para uma entrada de

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

você pode pintá-lo dessa maneira (ampliado para maior clareza):

Alguns casos de teste adicionais (seu código deve ser capaz de lidar com eles):

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


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



 / \
| * |
 \ /

Regras

• É garantido que a entrada possui pelo menos um hexágono e nenhuma entrada terá um "furo".
• Você não precisa começar sua coloração com vermelho, desde que mantenha a regra das três cores.
• Se o ladrilho parcial puder ser bicolor, você poderá fazê-lo sem penalidade (como no segundo exemplo) - não será necessário extrapolar o ladrilho parcial para um ladrilho completo.
• Os centros do hexágono *devem ser coloridos em vermelho, azul ou verde, enquanto as linhas entre eles devem ser ciano, amarelo ou magenta. Por exemplo, ter uma Magenta *não é permitido e um Vermelho |ou \ou /deve estar na borda externa do desenho. Veja Cores abaixo.
• Se o seu console não tiver essas cores exatas, use a aproximação mais próxima e especifique na sua resposta qual aproximação você está usando.
• Os espaços em branco à esquerda ou à direita, incluindo as novas linhas à direita, são aceitáveis ​​desde que os caracteres estejam alinhados.
• O mosaico parcial pode ser inserido com preenchimento de espaço para formar um retângulo, se isso facilitar o código.
• Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
• A saída pode ser no console, salva como imagem, etc.
• Lacunas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

Cores e misturas de cores:

As três cores base disponíveis são (com códigos de cores no formato decimal RGB):

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

As combinações são:

• Vermelho e Verde combinam para fazer Amarelo (255,255,0)
• Azul e verde combinam para fazer ciano (0,255,255)
• Vermelho e azul combinam para fazer 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>

Explicação: Cada caractere é envolto em uma fonttag para definir sua cor, que é calculada verificando cada quadrado, mais os quadrados dois à esquerda e à direita, mais os quatro quadrados um na diagonal, por *se combinando as cores de todos. *s encontrado. As *cores são escolhidas simplesmente tomando seu módulo de coordenadas horizontais 3 e deslocando uma máscara de bits adequadamente. Editar: salvou 2 bytes mudando de #RRGGBBpara #RGBcores.

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

Semelhante à minha abordagem de tela ; localiza todos os *s na string de entrada e grava hexágonos na página na forma de <pre>elementos absolutamente posicionados . Como mix-blend-modeestá definido como lighten, a adição de cores é realizada automaticamente quando os caracteres se sobrepõem.

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

Experimente online!

Golfe e conserto graças a user202729!
-27 bytes graças a Mr. Xcoder
-24 bytes graças 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

Experimente online!

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

Localiza todos os *s na sequência de entrada e pinta um hexágono ASCII na tela nas posições correspondentes. Porque globalCompositeOperation='lighter'a adição de cores é realizada automaticamente quando os caracteres se sobrepõem.

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

Um multiplicador e um scale()comando adicional foram adicionados ao snippet para visibilidade.

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

Veja também minha abordagem baseada em CSS .

MATLAB / oitava , 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

No formato de código um pouco mais limpo:

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

A entrada é tomada como uma matriz 2D, como digitar o seguinte quando a entrada é solicitada:

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

MATLAB, pelo que sei, não tem a capacidade de produzir cores para o console (exceto para hacks Java sujos que estou descontando). Como tal, a saída é impressa em uma figura.

A coloração é obtida encontrando a localização de todos *na entrada e, em seguida, em uma matriz de cores RGB (p ), uma caixa 5x3 de 1s (255 na representação de cores MATLAB) é escrita centralizada sobre o* . A caixa é gravada na cor correspondente ao índice mod-3 ao longo de cada linha, com linhas pares tendo o índice de cores alterado por um deslocamento.

Isso produz uma matriz de cores em que quaisquer caixas que se sobrepõem resultarão na cor mista necessária. O exemplo acima produz a seguinte matriz de cores.

As regiões branca e preta são irrelevantes porque nesses locais é impresso um espaço, o que significa que na verdade não vemos a cor incorreta.

Depois que a matriz de cores é criada, exibimos cada caractere em uma figura usando o textcomando, configurando a cor do texto para a entrada correspondente na matriz de cores. O exemplo acima exibirá: