Isenção de responsabilidade: a história contada nesta pergunta é inteiramente fictícia e inventada apenas com o objetivo de fornecer uma introdução.

Eu tenho um amigo que é arquiteto e, depois de explicar o conceito de código-golfe e este site, ele disse que eu deveria codificar algo realmente útil para uma mudança. Perguntei-lhe o que ele consideraria útil e, como arquiteto, ele respondeu que gostaria de ter uma planta que lhe desse todos os arranjos possíveis para salas de certos tamanhos em uma casa de um determinado tamanho. Pensei em provar que o código-golfe não era inútil, afinal, e fornecer a ele esse programa no menor número de bytes possível.

Sua tarefa:

Escreva um programa ou função que, quando for fornecida uma matriz D contendo as dimensões de toda a casa, e uma segunda matriz R contendo as dimensões das salas internas, produzidas como arte ASCII, todas as configurações possíveis das salas dentro da casa.

Todos os cômodos e as paredes externas da casa devem ser formados como caixas ASCII padrão, usando o | símbolo para paredes verticais, o símbolo - como paredes horizontais e o símbolo + para cantos. Por exemplo, uma casa com as dimensões [4,4] será semelhante a:

+----+
|    |
|    |
|    |
|    |
+----+

Como você pode ver, os cantos não contam como parte de um conjunto de dimensões. O número de - ou | os caracteres que formam um lado devem ser iguais ao número indicado nas dimensões. Os quartos podem compartilhar paredes ou compartilhar paredes com a casa. Uma sala não pode conter salas menores em si.

Por exemplo, a configuração

+--+---+-+
|  |   | |
|  |   | |
+--+---+ |
|        |
|        |
+--------+

é válido para D = [5,8] e R = [[2,2], [2,3]].

Entrada:

Duas matrizes, uma das quais contém dois números inteiros, as dimensões da casa e a outra contém uma série de matrizes que contêm as dimensões dos quartos.

Resultado:

Uma matriz de todas as casas possíveis como seqüências de caracteres ou uma sequência contendo todas as casas possíveis, delimitada de alguma maneira consistente. Observe que as rotações da mesma configuração exata devem ser contadas apenas uma vez.

Casos de teste:

D     R                   ->   Output

[4,3] [[2,1],[4,1]]       -> +-+-+ +-+-+ +-+-+  Note that though there is an option to switch which side the [2,1] room and the [4,1] room are on, doing so would merely be rotating the house by 180 degrees, and therefore these possibilities do not count.  
                             | | | +-+ | | | |
                             +-+ | | | | | | |
                             | | | | | | +-+ |
                             | | | +-+ | | | |
                             +-+-+ +-+-+ +-+-+

[4,7] [[3,1],[4,2],[2,2]  -> +----+--+ +----+--+ +----+--+ +----+--+  There are some more possiblities I didn't feel like adding, but it's the same four again, just with the [4,2] and the [2,2] room switched.  
                             |    |  | |    |  | |    |  | |    |  |
                             |    |  | |    |  | |    |  | |    |  |
                             +---++--+ +--+-+-++ +-+--++-+ ++---+--+
                             |   |   | |  |   || | |   | | ||   |  |
                             +---+---+ +--+---++ +-+---+-+ ++---+--+

Pontuação:

Isso é código-golfe , a menor pontuação em bytes ganha!

Python 2 , 625 607 602 563 551 bytes

1. -5 bytes graças ao Mr.Xcoder.
2. -12 bytes ao evitar cópias profundas.
3. -39 bytes com algumas simplificações da lista.

r,z=range,len
L,C=D;p,q,v,w=['+'],['|'],'*',' '
H=[p+['-']*C+p]
P=[[e[:]for e in H+[q+[w]*C+q]*L+H]]
def g(M,x,y,N):
 m=[e[:]for e in M]
 try:
  for i in r(z(N)):
   for j in r(z(N[0])):
	if v==N[i][j]and w!=M[x+i][y+j]:return[]
	m[x+i][y+j]=m[x+i][y+j]in[w,v,N[i][j]]and N[i][j]or'+'
 except:return[]
 return m
for l,c in R:
 H=[p+['-']*c+p]
 P=[g(U,x,y,[e[:]for e in H+[q+[v]*c+q]*l+H])for U in P for x in r(L+2)for y in r(C+2)]
F=[]
for m in P:
 if[e[::-1]for e in m[::-1]]not in F:F+=[m]
for m in F:
 print
 for e in m:print''.join(e).replace(v,w)

Experimente online!

Algumas explicações É uma abordagem gananciosa:

1. Encontre todas as posições em que o primeiro quarto pode ser alocado
2. Encontre todas as posições possíveis em que o próximo cômodo possa ser alocado a partir do espaço livre restante da casa e assim por diante nos outros cômodos.
3. Se a última sala tiver sido alocada com êxito, o código emitirá a configuração se ela não for uma rotação de 180 ° de uma configuração anterior.