È stato dimostrato che le seguenti 13 piastrelle quadrate Wang piastrellano sempre l'aereo aperiodicamente . Ciò significa che quando i quadrati sono disposti in una griglia con tutti i lati vicini dello stesso colore, una traslazione del motivo non corrisponderà mai a se stessa.

Rappresenteremo ogni tessera testualmente da una griglia 3 × 3 riempita con spazi al centro e agli angoli, e i numeri da 1 a 5 invece dei colori rosso, verde, blu, giallo, grigio, ai bordi:

 2      2      2      1      1      1      4      3      2      2      4      3      2
1 2    1 3    2 3    2 1    3 1    3 2    4 4    4 4    4 5    4 5    5 5    5 5    5 4
 3      2      3      2      3      2      1      2      1      4      1      2      2

Obbiettivo

Il tuo compito è scrivere un programma che includa larghezza e altezza e produca una griglia di piastrelle Wang valida con quelle dimensioni. Una piastrellatura valida è quella in cui tutti i bordi delle piastrelle adiacenti hanno lo stesso colore (o numero). Vince il programma più piccolo in byte.

Il tuo input dovrebbe provenire da argomenti stdin o della riga di comando e l'output dovrebbe andare a stdout. L'esatto formato di input può essere qualcosa di ragionevolmente ovvio, come >>> wangtiler 3 2. La larghezza e l'altezza sono sempre numeri interi positivi.

Esempio (larghezza = 3, altezza = 2)

Si noti che quando disponiamo le tessere testuali i bordi adiacenti formano coppie di cifre ridondanti necessarie:

 1  2  1 
2 11 22 1
 2  3  2 
 2  3  2 
4 55 55 4
 1  2  2 

^{(Questo NON è il formato di output corretto.)}

Possiamo comprimerli orizzontalmente e verticalmente per ottenere:

 1 2 1 
2 1 2 1
 2 3 2 
4 5 5 4
 1 2 2 

Questo formato compresso è il formato di output corretto che è necessario utilizzare. Le righe dispari devono includere il loro spazio finale.

Bonus grafico

Invece di avere un output testuale, il tuo programma potrebbe produrre un'immagine della griglia piastrellata. Le tessere grafiche devono essere composte da quattro triangoli 45-45-90 disposti in un quadrato e utilizzare cinque colori facilmente distinguibili come le tessere sopra. I bordi neri non sono richiesti. Le tessere grafiche devono avere una dimensione di almeno 32 × 32 pixel. Nessuna "compressione" è applicata a loro.

Immagine bonus di esempio: (stessa griglia dell'esempio sopra)

Il bonus vale meno 150 byte.

Gli appunti

• Devi usare questo set di 13 tessere.
• Le piastrelle non possono essere ruotate.
• Le piastrelle possono apparire un numero qualsiasi di volte (incluso nessuno).
• Si può presumere che sia possibile una piastrellatura valida con qualsiasi dimensione.

GolfScript, 200 caratteri

~\:W*):R;1,{)\:C"=QCy_~{MTKAis]?OyJE?~WvM"[64 2400]{base}/@{>}+,{:T;[C,W<!{C W~)=T 64/^8/8%}*C,W%0>{C-1=64/T^8%}*]0-!},1<.!!{1,+}*+.,R<}do);W/.0={' '\512/8%`}%n@{.[.0=8%\{' '\64/8%}/n]\{' '\8/8%`}%n}/

Versione ASCII senza output grafico. Dai l'input su STDIN - prova qui . Il codice utilizza un semplice approccio di backtracking e riempie lo spazio riga per riga.

Esempi:

> 3 2
 1 2 1
2 1 2 1
 2 3 2
5 4 4 5
 2 2 1

> 8 5
 1 2 1 2 1 2 1 2
2 1 2 1 2 1 2 1 2
 2 3 2 3 2 3 2 3
5 4 4 5 5 4 4 5 5
 2 2 4 2 2 2 4 2
5 4 5 5 4 5 4 4 5
 2 1 1 2 1 2 1 1
1 3 2 1 2 1 3 2 1
 2 2 2 3 2 2 2 2
5 4 5 4 4 5 4 5 4
 2 1 2 2 1 2 1 2

Bonus grafico, punteggio 122, 272 caratteri - 150 bonus

~\:W*):R;1,{)\:C"=QCy_~{MTKAis]?OyJE?~WvM"[64 2400]{base}/@{>}+,{:T;[C,W<!{C W~)=T 64/^8/8%}*C,W%0>{C-1=64/T^8%}*]0-!},1<.!!{1,+}*+.,R<}do);W["P3\n"32W*" "3$,32*n 1n]\{{:^;512:X;16,{[^8%]1$*[^X/8%]31*@.+>[^64/8%]31*++32<}:F%8:X;16,-1%{F}%+}%zip{{+}*{8+2base(;~}%' '*n}/}/

Stesso codice di base con un formattatore di output diverso. L'output è un'immagine in formato PPM (cioè semplicemente reindirizza l'output su un file image.ppm). I colori sono leggermente diversi rispetto alle piastrelle nella domanda, ma chiaramente distinguibili (1-> blu, 2-> verde, 3-> ciano, 4-> rosso, 5-> magenta).

Esempio 16x12:

Python (565-150 = 415)

A proposito ... sembra che non possiamo ingenuamente decidere la tessera successiva dalla tessera sinistra e superiore. C'è una combinazione di tessere che si adatteranno l'un l'altro.
Questa soluzione riempie le forze brute sinistra-> destra, top-> giù attraverso tutte le possibili combinazioni e backtrack se una piastrella non può adattarsi.

Per maggiori informazioni sulla prova delle 13 tessere: un set aperiodico di 13 tessere Wang

Larghezza e Altezza sono specificate da WeH

Rosso, Verde, Blu, Giallo e Noir specificate da R, G, B, YeN

import Image,sys
W,H=map(int,sys.argv[1:])
R=99
G=R<<8
B=G<<8
Y=G+R
N=0
s="RGB";u=32;g=[[0,0]]*W*H;k=f=0
def t(c):i=Image.new(s,(2,2));k=i.load();q=16;k[1,0],k[1,1],k[0,1],k[0,0]=c;return i.resize([64]*2).rotate(45).crop((q,q,q+u,q+u))
while k<H*W:
 z=g[k][1];v=-1;j=k/W;i=k%W
 while z<13:
    l=map(eval,"GGGRRRYBGGYBGGBBRRGYYNNNNYBGBGBGRGRYRGGRRGGBBYYYYNNN"[z::13])
    if(j<1or g[(j-1)*W+i][0][2]==l[0])and(i<1or g[j*W+i-1][0][1]==l[3]):g[k]=[l,z+1];v=1;z=99
    z+=1
 g[k][1]*=(v>0);k+=v
m=Image.new(s,(W*u,H*u))
for e in g:m.paste(t(e[0]),(f%W*u,(f/W)*u));f+=1
m.show()

Produzione. Non la combinazione di colori reale ... perché troppo evidente. Ciò potrebbe rendere interessanti alcuni motivi di arredamento d'interni ...:

Haskell, 208 byte

p x|x<2/3=(3!x)3"3212"3
p x=(0.5!x)1"45423"2
f=floor
(k!x)l s m=do{i<-[0,x..];[' ',s!!(2+f(i+x)-f i)]}:do{i<-[0,l*x..];s!!mod(f i)m:" "}:p(k*x)
t n=take$2*n+1
main=do(w,h)<-readLn;putStr.unlines.t h$t w<$>p 1

Nessuna ricerca, solo matematica. Esempio di esecuzione: dato (8,5)su stdin, output

 2 2 2 2 2 2 2 2 
4 5 4 5 4 5 4 5 4
 1 2 1 2 1 2 1 2 
3 2 3 2 3 2 3 2 3
 2 3 2 3 2 3 2 3 
4 5 5 4 4 5 5 4 4
 4 2 2 2 4 2 2 2 
4 4 5 4 5 5 4 5 4
 1 1 2 1 1 2 1 2 
3 2 1 3 2 1 3 2 3
 2 2 2 2 2 2 2 3 

Corri online su Ideone