Considere uma grade bidimensional retangular em que cada célula pode estar vazia ( .) ou cheia ( 0).

por exemplo

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

A grade é considerada infinita, todas as células fora da região representada estão vazias.

O objetivo é cobrir os espaços preenchidos e deixar os espaços vazios abertos usando um conjunto de 7 tijolos de formas distintas, cada um ocupando 4 células (2 × 2) da grade.

Estes são os 7 tijolos:

• Blocos - 1 variante

  11
  11
  

• Lajes - 2 variantes

  ..
  22

  33
  ..

• Escadas - 4 variantes

  .4
  44

  5.
  55

  66
  .6

  77
  7.

Esses tijolos sempre devem estar alinhados a uma grade cujas células têm o dobro da largura e altura das células da grade de entrada. Cada tijolo pode ocupar apenas uma célula dessa grade maior, mas a grade menor pode ser convertida (deslocada para cima, baixo, esquerda, direita) abaixo da grade maior para fornecer mais opções para encontrar uma cobertura. Nem as grades nem os tijolos individuais podem ser girados.

Então, uma maneira de cobrir (também conhecido como resolver) o exemplo acima é assim:

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

^{(Tijolos vizinhos idênticos ainda podem causar ambiguidade, mas a identificação cuidadosa da grade maior resolve isso.)}

Uma solução inválida para

000000
000000

é

566774
556744

porque nem todos os tijolos se alinham à grade maior, nem ocupam apenas uma célula dela.

Uma solução válida aqui é de 3 blocos seguidos:

111111
111111

E outra solução válida envolve 6 lajes:

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

Portanto, observe que algumas grades de entrada têm várias soluções .

Uma solução inválida para

00.00
00...

é

11.33
11...

porque os tijolos não se alinham à grade maior. A laje precisaria se mover para a esquerda ou direita por uma, mas é claro que a tampa ficaria incompleta. Essa grade de entrada não tem solução .

Desafio

Escreva um programa que capte (via stdin / linha de comando) um bloco retangular de texto de .'s 0' e que represente uma grade a ser coberta.

Se houver uma solução de cobertura válida, imprima (via stdout) qualquer uma das soluções da mesma maneira que acima, substituindo todas 0as 1por 7tijolos adequados .

Se não houver solução, seu programa não deve produzir nada, apenas terminar normalmente em silêncio.

Notas

• A entrada e a saída não precisam ter as mesmas dimensões retangulares. Sua saída pode ter linhas e / ou colunas estranhas de todos .(contanto que não invalidem a solução).

• Também é bom aparar linhas e colunas de todos ., se isso não afetar os espaços preenchidos. por exemplo

  222222
  333333
  

  é uma solução válida para

  000000
  000000
  

  Por outro lado, as duas colunas vazias 00..00não puderam ser removidas, pois isso desorganizaria os espaços preenchidos.

• Opcionalmente, você pode supor que a entrada tenha uma única nova linha à direita. Uma única nova linha à direita na saída também é boa, mesmo no caso de nenhuma solução.

• As grades completamente vazias (todas .) e a grade trivial 0 × 0 não são casos de entrada com os quais você precisa se preocupar. Mas a 0grade 1 × 1 é, assim como todas as outras grades que contêm pelo menos uma 0. (Você não pode presumir que a largura ou a altura da grade de entrada sejam iguais!)

• Em vez de um programa, você pode escrever uma função que aceita a entrada como um argumento de string e imprime a saída normalmente ou a retorna como uma string. Qualquer valor falso pode ser retornado se não houver solução.

• Você pode usar 9 caracteres ASCII imprimíveis distintos no lugar de . 0 1 2 3 4 5 6 7. Apenas certifique-se de dizer quais foram suas substituições! As novas linhas devem permanecer como estão.

Pontuação

O código mais curto em bytes vence. O desempate é o posto mais votado.

^{Esse desafio foi inspirado em blocos , lajes e escadas no Minecraft , que seguem as mesmas regras descritas aqui. Se você gosta de PPCG e Minecraft, você pode conferir o PPCG Minecraft Server .}

Python - 525 491 478 430 bytes

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"

Explicação: Este é o meu primeiro código de golfe, portanto, pode não ser o ideal, mas veja como ele funciona. A função t (s) fornece o resultado para a sequência passada. Primeiro, ele encontra o número de colunas, depois percorre as quatro traduções distintas possíveis por 1 (nenhuma, esquerda, cima, cima-esquerda) e tenta resolvê-lo. para cada um. Ele examina cada bloco 2x2 e o mapeia para um número de bloco válido, fornecido por um dicionário, e altera os zeros para o número.

Se encontrar um que não esteja no dicionário, abandona esse deslocamento específico e recomeça com o próximo. Se passar por todas as 4 compensações sem encontrar uma solução válida, termina sem gerar nada. a (v, i) permite o valor padrão fora da cadeia e ignora os caracteres de nova linha. Embora possa acabar com soluções parciais ao longo da duração da execução, sempre as substituirá pela correta final, se existir.

Editar: Um mapeamento diferente de caracteres é usado:. -> d, 0 -> z, todos os outros números vão para si mesmos. Isso se aplica à entrada e à saída.