Disclaimer: la storia raccontata all'interno di questa domanda è del tutto inventata e inventata esclusivamente allo scopo di fornire un'introduzione.

Ho un amico che è un architetto e, dopo avergli spiegato il concetto di code-golf e questo sito, ha detto che avrei dovuto codificare qualcosa di veramente utile per un cambiamento. Gli chiesi cosa avrebbe ritenuto utile e, essendo un architetto, mi rispose che gli sarebbe piaciuto avere un pianificatore che gli fornisse tutte le possibili disposizioni per stanze di determinate dimensioni all'interno di una casa di una certa dimensione. Pensavo che avrei dimostrato che il code-golf non era affatto inutile, e gli avrei dato questo programma nel minor numero di byte possibile.

Il tuo compito:

Scrivi un programma o una funzione che, quando viene fornita una matrice D contenente le dimensioni dell'intera casa, e una seconda matrice R contenente le dimensioni delle stanze interne, emesse come arte ASCII, tutte le possibili configurazioni delle stanze all'interno della casa.

Tutte le stanze e le pareti esterne della casa dovrebbero essere formate come scatole ASCII standard, usando il | il simbolo per le pareti verticali, il simbolo - come pareti orizzontali e il simbolo + per gli angoli. Ad esempio, una casa con le dimensioni [4,4] sarà simile a:

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

Come puoi vedere, gli angoli non contano come parte di un insieme di dimensioni. Il numero di - o | i caratteri che formano un lato devono essere uguali al numero indicato nelle dimensioni. Le stanze possono condividere muri o condividere muri con la casa. Una stanza non può contenere stanze più piccole al suo interno.

Ad esempio, la configurazione

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

è valido per D = [5,8] e R = [[2,2], [2,3]].

Ingresso:

Due matrici, una delle quali contiene due numeri interi, le dimensioni della casa e l'altra contiene una serie di matrici che contengono le dimensioni delle stanze.

Produzione:

Una matrice di tutte le case possibili come stringhe o una stringa contenente tutte le case possibili, delimitata in modo coerente. Si noti che le rotazioni della stessa identica configurazione devono essere conteggiate una sola volta.

Casi test:

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

punteggio:

Questo è code-golf , il punteggio più basso in byte vince!

Python 2 , 625 607 602 563 551 byte

1. -5 byte grazie a Mr.Xcoder.
2. -12 byte quando si evita la copia in profondità.
3. -39 byte con alcune semplificazioni dell'elenco.

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)

Provalo online!

Alcune spiegazioni È un approccio avido:

1. Trova tutte le posizioni in cui è possibile assegnare la prima stanza
2. Trova tutte le posizioni possibili in cui la stanza successiva può essere allocata dallo spazio libero rimanente della casa, e così via per le altre stanze.
3. Se l'ultima stanza è stata allocata correttamente, il codice genera la configurazione se non è una rotazione di 180 ° rispetto a una configurazione precedente.