CJam, 94 92 82 bytes
Esta es la versión de 92 bytes. Sigue la versión de 82 bytes.
l~1$,:L,:)m*{1bL=},\e!\m*{~W<{/(\e_}%}%{::+)-!},{{_,,\f<1fb}%2ew{:&,(},!}={{(2*'_*'[\']}/N}/
Esto divide los ladrillos en todas las formas posibles y toma solo el que es válido. Fuerza bruta bastante por ahora, pero aún ejecuta el último caso de prueba en unos 10 segundos en el intérprete de Java en mi máquina.
Explicacion :
El código se divide en 5 partes:
1) Dada una matriz de longitud L, ¿cómo podemos dividirla en Hpartes?
l~1$,:L,:)m*{1bL=},
l~ e# Read the input as string and evaluate it.
`$,:L e# Copy the array and take its length. Store that in L
,:) e# Get an array of 1 to L
m* e# Cartesian power of array 1 to L of size H (height of wall)
{1bL=}, e# Take only those parts whose sum is L
Después de esto, tenemos todas las formas posibles de dividir nuestra matriz de entrada en capas de ladrillo H.
2) Obtenga todas las permutaciones de la matriz de entrada y luego obtenga todas las particiones para todas las permutaciones
\e!\m*{~W<{/(\e_}%}%
\e! e# Put the input array on top of stack and get all its permutations
\m* e# Put the all possible partition array on top and to cartesian
e# product of the two permutations. At this point, every
e# permutation of the input array is linked up with every
e# permutation of splitting L sized array into H parts
{ }% e# Run each permutation pair through this
~W< e# Unwrap and remove the last part from the partition permutation
{ }% e# For each part of parts permutation array
/ e# Split the input array permutation into size of that part
(\ e# Take out the first part and put the rest of the parts on top
e_ e# Flatten the rest of the parts so that in next loop, they can be
e# split into next part length
Después de esto, tenemos todos los diseños posibles de los ladrillos de entrada en una Hpared de ladrillo de capas.
3) Filtre solo aquellos diseños cuyas longitudes de ladrillo sean iguales
{::+)-!},
{ }, e# Filter all brick layouts on this condition
::+ e# Add up brick sizes in each layer
)-! e# This checks if the array contains all same lengths.
Después del final de este filtro, todos los diseños restantes serían rectángulos perfectos.
4) Saque el primer diseño de ladrillo que coincida con los criterios de estabilidad
{{_,,\f<1fb}%2ew{:&,(},!}=
{ }= e# Choose the first array element that leaves truthy on stack
{ }% e# For each brick layer
_,, e# Create an array of 0 to layer length - 1
\f< e# Get all sublists starting at 0 and ending at 0
e# through length - 1
1fb e# Get sum of each sub list. This gives us the cumulative
e# length of each brick crack except for the last one
2ew e# Pair up crack lengths for every adjacent layer
{ }, e# Filter layer pairs
:& e# See if any cumulative crack length is same in any two
e# adjacent layers. This means that the layout is unstable
,( e# make sure that length of union'd crack lengths is greater
e# than 1. 1 because 0 will always be there.
! e# If any layer is filtered through this filter,
e# it means that the layer is unstable. Thus negation
Después de este paso, simplemente tenemos que imprimir el diseño.
5) Imprimir el diseño
{{(2*'_*'[\']}/N}/
{ }/ e# For each brick layer
{ }/ e# For each brick
(2*'_* e# Get the (brick size - 1) * 2 underscores
'[\'] e# Surround with []
N e# Newline after each layer
Pruébalo en línea aquí
82 bytes
l~:H;{e_mrH({H-X$,+(mr)/(\e_}%_::+)-X${_,,\f<1fb}%2ew{:&,(},+,}g{{(2*'_*'[\']}/N}/
Esto es casi similar a la versión de 92 bytes, excepto que tiene un toque de aleatoriedad. Si ha leído la explicación de la versión de 92 bytes, en la versión de 82 bytes, las partes 3, 4 y 5 son exactamente iguales, mientras que en lugar de repetir todas las permutaciones de las partes 1 y 2, esta versión simplemente genera aleatoriamente una de las permutación a la vez, lo prueba usando las partes 3 y 4, y luego reinicia el proceso si las pruebas de las partes 3 y 4 fallan.
Esto imprime los resultados muy rápidamente para los primeros 3 casos de prueba. El caso de prueba height = 5 todavía tiene que dar una salida en mi computadora.
Explicación de la diferencia.
l~:H;{e_mrH({H-X$,+(mr)/(\e_}%_::+)-X${_,,\f<1fb}%2ew{:&,(},+,}g
l~:H; e# Eval the input and store the height in H
{ ... }g e# A do-while loop to iterate until a solution is found
e_mr e# Flatten the array and shuffle it.
H({ }% e# This is the random partition generation loop
e# Run the loop height - 1 times to get height parts
H-X$,+( e# While generating a random size of this partition, we
e# have to make sure that the remaining parts get at least
e# 1 brick. Thus, this calculation
mr) e# Get a random size. Make sure its at least 1
/(\e_ e# Similar to 92's part 2. Split, pop, swap and flatten
_::+)- e# 92's part 3. Copy and see if all elements are same
X${_,,\f<1fb}%2ew{:&,(}, e# 92's part 4. Copy and see if layers are stable
+, e# Both part 3 and 4 return empty array if
e# the layout is desirable. join the two arrays and
e# take length. If length is 0, stop the do-while
La idea para esta versión fue dada por randomra (¿Entiendes?)
Prueba este en línea