Avertissement: L'histoire racontée dans cette question est entièrement fictive et inventée uniquement dans le but de fournir une intro.

J'ai un ami qui est architecte et, après lui avoir expliqué le concept de code-golf et ce site, il a dit que je devrais coder quelque chose de réellement utile pour un changement. Je lui ai demandé ce qu'il jugerait utile et, en tant qu'architecte, il a répondu qu'il aimerait avoir un planificateur d'étage qui lui donnerait toutes les dispositions possibles pour des pièces de certaines tailles dans une maison d'une certaine taille. Je pensais prouver que le code-golf n'était pas inutile après tout, et lui donner ce programme dans le plus petit nombre d'octets possible.

Ta tâche:

Écrivez un programme ou une fonction qui, lorsqu'on lui donne un tableau D contenant les dimensions de la maison entière, et un deuxième tableau R contenant les dimensions des pièces intérieures, produit en tant qu'art ASCII, toutes les configurations possibles des pièces à l'intérieur de la maison.

Toutes les pièces et les murs extérieurs de la maison doivent être formés comme des boîtes ASCII standard, en utilisant le | symbole pour les murs verticaux, le symbole - pour les murs horizontaux et le symbole + pour les coins. Par exemple, une maison aux dimensions [4,4] ressemblera à:

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

Comme vous pouvez le voir, les coins ne comptent pas comme faisant partie d'un ensemble de dimensions. Le nombre de - ou | les caractères formant un côté doivent être égaux au nombre indiqué dans les dimensions. Les chambres peuvent partager des murs ou partager des murs avec la maison. Une pièce ne peut pas contenir de petites pièces en elle-même.

Par exemple, la configuration

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

est valable pour D = [5,8] et R = [[2,2], [2,3]].

Contribution:

Deux tableaux, dont l'un contient deux entiers, les dimensions de la maison, et l'autre contient une série de tableaux contenant les dimensions des pièces.

Production:

Soit un tableau de toutes les maisons possibles sous forme de chaînes, soit une chaîne contenant toutes les maisons possibles, délimitées de manière cohérente. Notez que les rotations de la même configuration exacte ne doivent être comptées qu'une seule fois.

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

Notation:

C'est le code-golf , le score le plus bas en octets gagne!

Python 2 , 625 607 602 563 551 octets

1. -5 octets grâce à Mr.Xcoder.
2. -12 octets pour éviter la copie en profondeur.
3. -39 octets avec quelques simplifications de liste.

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)

Essayez-le en ligne!

Quelques explications C'est une approche gourmande:

1. Trouver tous les postes où la première salle peut être attribuée
2. Trouvez toutes les positions possibles où la pièce suivante peut être attribuée à partir de l'espace libre restant de la maison, et ainsi de suite pour les autres pièces.
3. Si la dernière pièce a été affectée avec succès, le code affiche la configuration si ce n'est pas une rotation à 180 ° d'une configuration précédente.