Sześciokątne teselacje lub nachylenia płaszczyzny są trójkolorowe - co oznacza, że ​​przy użyciu tylko trzech kolorów, takich jak czerwony, niebieski i zielony, każdy sześciokąt można pokolorować bez żadnych dwóch sześciokątów, które mają wspólną granicę. Częściowy przykład pokazujący taki wzór.

Biorąc pod uwagę częściowe kafelkowanie heksagonalne w ASCII (przez STDIN, czytanie z pliku itp.), Zmień kolory znaków (za pomocą kodów ANSI, manipulacji obrazem itp.), Aby pasowały do ​​tego koloru. Skręt jest środkiem sześciokątów ( *poniżej) to trzy kolory, a linie między nimi muszą być mieszanką dwóch odpowiadających im *kolorów heksa . Jeśli linia znajduje się na zewnętrznej granicy, powinna pasować do odpowiedniej *.

Na przykład, biorąc pod uwagę częściowe sześciokątne układanie płytek

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

przypuśćmy, że zdecydujemy się pokolorować lewy górny heks *na Czerwony, a jego dwóch sąsiadów na Niebieski i Zielony (zgodnie z ruchem wskazówek zegara). Następnie |linia musi być Magenta, a /linia żółta. Jeśli nadal będziemy kolorować, w końcu otrzymamy coś takiego (powiększonego dla przejrzystości):

Lub, dla wejścia

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

możesz go tak pokolorować (powiększony dla przejrzystości):

Kilka dodatkowych przypadków testowych (twój kod powinien być w stanie obsłużyć te):

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


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



 / \
| * |
 \ /

Zasady

• Gwarantowane wejście ma co najmniej jeden sześciokąt i żadne wejście nie będzie miało „dziury”.
• Nie musisz rozpoczynać kolorowania od czerwonego, o ile zachowasz zasadę trzech kolorów.
• Jeśli częściowe kafelki mogą być dwukolorowe, możesz to zrobić bez kary (tak jak w drugim przykładzie) - niekoniecznie musisz ekstrapolować częściowe kafelki na pełne kafelki.
• Centra sześciokąta *muszą być zabarwione na czerwono, niebiesko lub zielono, natomiast linie między nimi muszą mieć kolor cyjan, żółty lub purpurowy. Na przykład posiadanie karmazynu *jest niedozwolone, a czerwony |lub \lub /musi znajdować się na zewnętrznej granicy rysunku. Zobacz Kolory poniżej.
• Jeśli twoja konsola nie ma tych dokładnych kolorów, użyj najbliższego przybliżenia i podaj w odpowiedzi, jakiego przybliżenia używasz.
• Dopuszczalne lub końcowe białe spacje, w tym końcowe znaki nowej linii, są dopuszczalne, o ile znaki są w linii.
• Częściowe kafelkowanie można wprowadzić za pomocą spacji, aby utworzyć prostokąt, jeśli ułatwi to kodowi.
• Dopuszczalny jest pełny program lub funkcja. Jeśli funkcja, możesz zwrócić dane wyjściowe zamiast je drukować.
• Dane wyjściowe mogą być wysyłane do konsoli, zapisane jako obraz itp.
• Standardowe luki są zabronione.
• To jest golf golfowy, więc obowiązują wszystkie zwykłe zasady gry w golfa, a wygrywa najkrótszy kod (w bajtach).

Kolory i mieszanki kolorów:

Trzy dostępne kolory podstawowe to (z kodami kolorów w formacie dziesiętnym RGB):

• Czerwony (255,0,0)
• Zielony (0,255,0)
• niebieski (0,0,255)

Kombinacje to:

• Czerwony i zielony łączą się, tworząc żółty (255,255,0)
• Niebieski i zielony łączą się, tworząc Cyan (0,255,255)
• Czerwony i niebieski tworzą magenta (255,0,255)

JavaScript (ES6), 219 203 201 bajtów

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>

Objaśnienie: Każda postać jest owinięta fontznacznikiem, aby ustawić jej kolor, który jest obliczany przez sprawdzenie każdego kwadratu, plus kwadraty dwa po lewej i prawej stronie, oraz cztery kwadraty jeden po przekątnej, dla *si, a jeśli tak, łączenie kolorów wszystkich *znaleziono. Te *kolory są wybrane po prostu poprzez koordynowania ich poziomy modulo 3 i przesunięcie bitową odpowiednio. Edit: Saved 2 bajty przez przejście z #RRGGBBdo #RGBkolorów.

JavaScript (ES6), 210 bajtów (przy użyciu HTML + CSS)

Podobne do mojego podejścia do płótna ; lokalizuje wszystkie *s w ciągu wejściowym i zapisuje sześciokąty na stronie w postaci absolutnie pozycjonowanych <pre>elementów. Ponieważ mix-blend-modejest ustawiony na lighten, dodawanie kolorów odbywa się automatycznie, gdy znaki nakładają się na siebie.

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 bajtów

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

Wypróbuj online!

Gra w golfa i naprawiono dzięki user202729!
-27 bajtów dzięki Mr. Xcoder
-24 bajtów dzięki Jonathan Frech

Python 2 , 346 331 bajtów

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

Wypróbuj online!

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

Lokalizuje wszystkie *s w ciągu wejściowym i maluje sześciokąt ASCII na płótnie w odpowiednich pozycjach. Ponieważ globalCompositeOperation='lighter'dodawanie kolorów odbywa się automatycznie, gdy znaki nakładają się na siebie.

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

W scale()celu zwiększenia widoczności we fragmencie dodano mnożnik i dodatkowe polecenie.

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

Zobacz także moje podejście oparte na CSS .

MATLAB / Octave , 223 bajty

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

W nieco starszym formacie kodu:

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

Dane wejściowe są traktowane jako tablica 2D, na przykład wprowadzenie następujących po wyświetleniu monitu o wprowadzenie:

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

O ile mi wiadomo, MATLAB nie ma możliwości wyświetlania kolorów na konsoli (z wyjątkiem brudnych hacków Java, które dyskontuję). W związku z tym wynik jest drukowany na rysunku.

Kolorowanie uzyskuje się poprzez znalezienie położenia wszystkich *na wejściu, a następnie w tablicy kolorów RGB ( p), pole 1 x 5x3 (255 w reprezentacji kolorów MATLAB) jest pisane na środku *. Pole jest zapisywane w kolorze odpowiadającym indeksowi mod-3 wzdłuż każdej linii, przy czym linie parzyste mają przesunięty indeks koloru o przesunięcie.

W ten sposób powstaje matryca kolorów, w której nakładające się pola będą dawały wymagany kolor mieszany. Powyższy przykład tworzy następującą matrycę kolorów.

Białe i czarne obszary nie mają znaczenia, ponieważ w tych miejscach drukowana jest spacja, co oznacza, że ​​nie widzimy niewłaściwego koloru.

Po utworzeniu matrycy kolorów wyświetlamy każdy znak na rysunku za pomocą textpolecenia, ustawiając kolor tekstu na odpowiedni wpis w matrycy kolorów. Powyższy przykład wyświetli: