Descargo de responsabilidad: La historia contada dentro de esta pregunta es completamente ficticia e inventada únicamente con el propósito de proporcionar una introducción.

Tengo un amigo que es arquitecto y, después de explicarle el concepto de golf de código y este sitio, me dijo que debería codificar algo realmente útil para un cambio. Le pregunté qué consideraría útil y, como arquitecto, respondió que disfrutaría tener un planificador de pisos que le diera todos los arreglos posibles para habitaciones de ciertos tamaños dentro de una casa de cierto tamaño. Pensé que probaría que el golf de código no era inútil después de todo, y darle este programa en la menor cantidad de bytes posible.

Tu tarea:

Escriba un programa o función que, cuando se le dé una matriz D que contenga las dimensiones de toda la casa, y una segunda matriz R que contenga las dimensiones de las habitaciones interiores, salida como arte ASCII, todas las configuraciones posibles de las habitaciones dentro de la casa.

Todas las habitaciones y las paredes exteriores de la casa deben formarse como cajas ASCII estándar, utilizando el | símbolo para paredes verticales, el símbolo - como paredes horizontales y el símbolo + para esquinas. Por ejemplo, una casa con las dimensiones [4,4] se verá así:

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

Como puede ver, las esquinas no cuentan como parte de un conjunto de dimensiones. El número de - o | los caracteres que forman un lado deben ser iguales al número dado en las dimensiones. Las habitaciones pueden compartir paredes o compartir paredes con la casa. Una habitación no puede contener habitaciones más pequeñas dentro de sí misma.

Por ejemplo, la configuración

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

es válido para D = [5,8] y R = [[2,2], [2,3]].

Entrada:

Dos conjuntos, uno de los cuales contiene dos enteros, las dimensiones de la casa, y el otro contiene una serie de conjuntos que contienen las dimensiones de las habitaciones.

Salida:

Ya sea una matriz de todas las casas posibles como cadenas, o una cadena que contiene todas las casas posibles, delimitada de alguna manera consistente. Tenga en cuenta que las rotaciones de la misma configuración exacta solo deben contarse una vez.

Casos de prueba:

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.  
                             |    |  | |    |  | |    |  | |    |  |
                             |    |  | |    |  | |    |  | |    |  |
                             +---++--+ +--+-+-++ +-+--++-+ ++---+--+
                             |   |   | |  |   || | |   | | ||   |  |
                             +---+---+ +--+---++ +-+---+-+ ++---+--+

Puntuación:

Este es el código de golf , ¡la puntuación más baja en bytes gana!

Python 2 , 625 607 602 563 551 bytes

1. -5 bytes gracias a Mr.Xcoder.
2. -12 bytes al evitar la copia profunda.
3. -39 bytes con algunas simplificaciones de 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)

Pruébalo en línea!

Algunas explicaciones Es un enfoque codicioso:

1. Encuentre todas las posiciones donde se puede asignar la primera sala
2. Encuentre todas las posiciones posibles donde se puede asignar la siguiente habitación desde el espacio libre restante de la casa, y así sucesivamente para las otras habitaciones.
3. Si la última habitación se asignó con éxito, el código genera la configuración si no es una rotación de 180 ° de una configuración anterior.