Considera una griglia rettangolare bidimensionale in cui ogni cella può essere vuota ( .) o full ( 0).

per esempio

..00....
0000....
.00000..
000...00
..000000
000.00..

La griglia è considerata infinita, tutte le celle al di fuori della regione rappresentata sono vuote.

L'obiettivo è quello di coprire gli spazi pieni e lasciare aperti gli spazi vuoti usando un set di 7 mattoni dalla forma distintiva che occupano ciascuno 4 celle (2 × 2) della griglia.

Questi sono i 7 mattoni:

• Blocchi - 1 variante

  11
  11
  

• Lastre - 2 varianti

  ..
  22

  33
  ..

• Scale - 4 varianti

  .4
  44

  5.
  55

  66
  .6

  77
  7.

Questi mattoni devono sempre allinearsi a una griglia le cui celle sono due volte più larghe e alte delle celle della griglia di input. Ogni mattone può occupare solo una cella di questa griglia più grande, ma la griglia più piccola può essere tradotta (spostata in alto, in basso, a sinistra, a destra) sotto la griglia più grande per offrire più opzioni per trovare una copertura. Né le griglie né i singoli mattoni possono essere ruotati.

Quindi un modo per coprire (aka risolvere) l'esempio sopra è così:

..11....
2211....
.47733..
447...22
..771133
227.11..

^{(I mattoni identici adiacenti possono ancora causare ambiguità, ma l'identificazione accurata della griglia più grande lo risolve.)}

Una soluzione non valida per

000000
000000

è

566774
556744

perché i mattoni non si allineano tutti alla griglia più grande né ne occupano solo una cella.

Una soluzione valida qui è di 3 blocchi di fila:

111111
111111

E un'altra soluzione valida prevede 6 lastre:

......
222222
333333
......

Quindi, nota che alcune griglie di input hanno più soluzioni .

Una soluzione non valida per

00.00
00...

è

11.33
11...

perché i mattoni non si allineano alla griglia più grande. La lastra dovrebbe spostarsi a sinistra o a destra di una, ma ovviamente la copertina sarebbe incompleta. Questa griglia di input ha non soluzione .

Sfida

Scrivi un programma che contiene (tramite stdin / riga di comando) un blocco rettangolare di testo di .'s e0 " che rappresenta una griglia da coprire.

Se c'è una soluzione valida copertura, stampa (tramite stdout) qualsiasi una soluzione nello stesso modo descritto sopra, sostituendo tutti 0's con l'appropriato 1attraverso7 mattoni .

Se non c'è soluzione, il tuo programma non dovrebbe produrre nulla, ma termina normalmente in silenzio.

Appunti

• L'input e l'output non devono necessariamente avere le stesse dimensioni rettangolari. Il tuo output può avere righe e / o colonne estranee di tutte .(purché non invalidino la soluzione).

• Va anche bene tagliare le righe e le colonne di tutto .se non influisce sugli spazi riempiti. per esempio

  222222
  333333
  

  è una soluzione valida per

  000000
  000000
  

  Al contrario, le due colonne vuote in 00..00non potevano essere rimosse poiché ciò avrebbe confuso gli spazi riempiti.

• Si può facoltativamente supporre che l'input abbia una nuova riga finale. Anche una sola nuova riga finale nell'output va bene, anche nel caso di nessuna soluzione.

• Le griglie completamente vuote (tutte .) e la banale griglia 0 × 0 non sono casi di input di cui devi preoccuparti. Ma la 0griglia 1 × 1 è, come lo sono tutte le altre griglie che ne contengono almeno una 0. (Non puoi supporre che la larghezza o l'altezza della griglia di input sia pari!)

• Invece di un programma è possibile scrivere una funzione che accetta l'input come argomento stringa e stampa l'output normalmente o lo restituisce come stringa. Qualsiasi valore di falsa può essere restituito se non c'è soluzione.

• È possibile utilizzare qualsiasi 9 caratteri ASCII stampabili distinti al posto di . 0 1 2 3 4 5 6 7. Assicurati di dire quali erano le tue sostituzioni! Newline deve rimanere così com'è.

punteggio

Vince il codice più breve in byte. Tiebreaker è il post più votato.

^{Questa sfida è stata ispirata da blocchi , lastre e scale in Minecraft , che seguono le stesse regole descritte qui. Se ti piacciono PPCG e Minecraft, potresti voler controllare il server PPCG Minecraft .}

Python - 525 491 478 430 byte

r=range
def t(s):
 m=s.find("\n")+1
 for q in r(4):
  try:
   for i in r(-q%2,m-1,2):
    for j in r(-q/2,len(s)/m,2):
     k,g=j*m+i,""
     b=[k,k+1,k+m,k+m+1]
     for z in b:g+=a(s,z)
     for z in b:
      if a(s,z)!="d":s=s[:z]+`dict(dddd=0,zzdd=3,ddzz=2,zzzd=7,zzdz=6,zdzz=5,dzzz=4,zzzz=1)[g]`+s[z+1:]
   return s
  except:d
def a(v,i):
 try:
  if v[i]!="\n":return v[i]
  return "d"
 except:return "d"

Spiegazione: Questo è il mio primo codice golf, quindi potrebbe non essere ottimale, ma ecco come funziona. La funzione t (s) fornisce il risultato per la stringa passata. Prima trova il numero di colonne, quindi passa attraverso le quattro possibili traduzioni distinte per 1 (nessuna, sinistra, su, su-sinistra) e cerca di risolverlo per ognuno. Guarda ogni blocco 2x2 e lo mappa su un numero di blocco valido, dato da un dizionario, e cambia gli zeri sul numero.

Se ne trova uno non presente nel dizionario, abbandona lo scostamento specifico e ricomincia da quello successivo. Se attraversa tutti e 4 gli offset senza trovare una soluzione valida, termina senza emettere nulla. a (v, i) consente il valore predefinito all'esterno della stringa e ignora i caratteri di nuova riga. Sebbene possa finire con soluzioni parziali per tutta la durata della corsa, le sostituirà sempre con l'ultima corretta se esiste.

Modifica: viene utilizzata una diversa mappatura dei caratteri:. -> d, 0 -> z, tutti gli altri numeri vanno da soli. Questo vale sia per input che per output.