Les pavages hexagonaux , ou pavages de l'avion, sont tricolores - ce qui signifie qu'en utilisant seulement trois couleurs, comme le rouge, le bleu et le vert, chaque hexagone peut être coloré sans que deux hexagones partagent une bordure partageant une couleur. Un exemple partiel montrant un tel modèle.

Étant donné un pavage hexagonal partiel en ASCII (via STDIN, lecture à partir d'un fichier, etc.), changez les couleurs des caractères (via les codes ANSI, manipulation d'image, etc.) pour s'adapter à cette coloration. La torsion est le milieu des hexagones (les *ci-dessous) sont les trois couleurs, et les lignes entre doivent être un mélange de leurs deux *couleurs hexagones correspondantes . Si la ligne est sur la bordure extérieure, elle doit correspondre à la ligne correspondante *.

Par exemple, étant donné le pavage hexagonal partiel de

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

supposons que nous décidions de colorier l'hex en haut à gauche *pour être rouge, et ses deux voisins pour être bleu et vert (dans le sens horaire). Ensuite, la |ligne doit être magenta et la /ligne doit être jaune. Si nous continuons à colorier, nous finirons par arriver à quelque chose comme ça (agrandi pour plus de clarté):

Ou, pour une entrée de

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

vous pouvez le colorer ainsi (agrandi pour plus de clarté):

Quelques cas de test supplémentaires (votre code devrait être capable de les gérer):

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


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



 / \
| * |
 \ /

Règles

• L'entrée est garantie d'avoir au moins un hexagone, et aucune entrée n'aura de "trou".
• Vous n'avez pas besoin de commencer votre coloration avec du rouge, tant que vous maintenez la règle des trois couleurs.
• Si le pavage partiel peut être bicolore, vous pouvez le faire sans pénalité (comme dans le deuxième exemple) - vous n'avez pas nécessairement besoin d'extrapoler le pavage partiel à un pavage complet.
• Les centres hexagonaux *doivent être colorés en rouge, bleu ou vert, tandis que les lignes entre doivent être cyan, jaune ou magenta. Par exemple, avoir un Magenta *n'est pas autorisé et un Rouge| ou \ou /doit être sur la bordure extérieure du dessin. Voir Couleurs ci-dessous.
• Si votre console n'a pas ces couleurs exactes, veuillez utiliser l'approximation la plus proche et spécifier dans votre réponse l'approximation que vous utilisez.
• Les espaces blancs de début ou de fin, y compris les retours à la ligne de fin, sont acceptables tant que les caractères s'alignent.
• Le pavage partiel peut être saisi avec un espace pour former un rectangle, si cela facilite la tâche de votre code.
• Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
• La sortie peut être vers la console, enregistrée en tant qu'image, etc.
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

Couleurs et mélanges de couleurs:

Les trois couleurs de base disponibles sont (avec des codes de couleur au format décimal RVB):

• rouge (255,0,0)
• vert (0,255,0)
• Bleu (0,0,255)

Les combinaisons sont:

• Le rouge et le vert se combinent pour faire du jaune (255,255,0)
• Le bleu et le vert se combinent pour faire du cyan (0,255,255)
• Le rouge et le bleu se combinent pour faire du magenta (255,0,255)

JavaScript (ES6), 219 203 201 octets

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>

Explication: Chaque caractère est enveloppé dans une fontbalise pour définir sa couleur, qui est calculée en vérifiant chaque carré, plus les carrés deux à gauche et à droite, plus les quatre carrés un en diagonale, pour *s et si c'est le cas en combinant les couleurs de tous *s trouvé. Les *couleurs sont choisies simplement en prenant leur coordonnée horizontale modulo 3 et en déplaçant un masque de bits de manière appropriée. Modifier: enregistré 2 octets en passant de #RRGGBBaux #RGBcouleurs.

JavaScript (ES6), 210 octets (en utilisant HTML + CSS)

Similaire à mon approche de la toile ; localise tous les *s dans la chaîne d'entrée et écrit des hexagones dans la page sous la forme d' <pre>éléments absolument positionnés . Parce que mix-blend-modeest défini sur lighten, l'ajout de couleur est effectué automatiquement lorsque les caractères se chevauchent.

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 octets

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

Essayez-le en ligne!

Golfé et réparé grâce à user202729!
-27 octets grâce à M. Xcoder
-24 octets grâce à Jonathan Frech

Python 2 , 346 331 octets

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

Essayez-le en ligne!

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

Localise tous les *s dans la chaîne d'entrée et peint un hexagone ASCII sur le canevas aux positions correspondantes. CarglobalCompositeOperation='lighter' ajout de couleur est effectué automatiquement lorsque les caractères se chevauchent.

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 multiplicateur et une scale()commande supplémentaire ont été ajoutés à l'extrait de code pour plus de 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>

Voir également mon approche basée sur CSS .

MATLAB / Octave , 223 octets

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

Au format de code légèrement plus net:

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'entrée est prise comme un tableau 2D, par exemple en entrant ce qui suit lorsque vous y êtes invité:

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

Pour autant que je sache, MATLAB n'a pas la possibilité de sortir des couleurs sur la console (à l'exception des hacks Java sales que je remets en cause). En tant que tel, la sortie est imprimée à la place sur une figure.

La coloration est obtenue en trouvant l'emplacement de tous *dans l'entrée, puis dans un tableau de couleurs RVB ( p), une boîte 5x3 de 1 (255 dans la représentation des couleurs MATLAB) est écrite centrée sur le* . La boîte est écrite dans la couleur correspondant à l'index mod-3 le long de chaque ligne, les lignes paires ayant l'indice de couleur décalé d'un décalage.

Cela produit une matrice de couleurs où toutes les cases qui se chevauchent entraîneront la couleur mélangée requise. L'exemple ci-dessus produit la matrice de couleurs suivante.

Les régions blanches et noires ne sont pas pertinentes car à ces endroits, un espace est imprimé, ce qui signifie que nous ne voyons pas la couleur incorrecte.

Une fois la matrice de couleurs créée, nous affichons chaque caractère sur une figure à l'aide de la textcommande, en définissant la couleur du texte sur l'entrée correspondante dans la matrice de couleurs. L'exemple ci-dessus affichera: