CJam, 94 92 82 Bytes
Dies ist die 92-Byte-Version. Es folgt die 82-Byte-Version.
l~1$,:L,:)m*{1bL=},\e!\m*{~W<{/(\e_}%}%{::+)-!},{{_,,\f<1fb}%2ew{:&,(},!}={{(2*'_*'[\']}/N}/
Dadurch werden die Bausteine in alle möglichen Arten unterteilt und es wird nur der gültige verwendet. Momentan ziemlich brachial, aber der letzte Testfall wird in ungefähr 10 Sekunden auf dem Java-Interpreter auf meinem Computer ausgeführt.
Erklärung :
Der Code ist in 5 Teile aufgeteilt:
1) LWie können wir ein Array mit einer gegebenen Länge in HTeile unterteilen?
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
Danach haben wir alle Möglichkeiten, unser Input-Array in H-Brick-Layer aufzuteilen.
2) Holen Sie sich alle Permutationen des Eingabearrays und holen Sie sich dann alle Partitionen für alle Permutationen
\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
Danach haben wir alle möglichen Layouts der Eingabebausteine in einer HEbenenmauer.
3) Filtern Sie nur die Layouts heraus, deren Ziegelsteinlängen gleich sind
{::+)-!},
{ }, 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.
Nach dem Ende dieses Filters wären alle verbleibenden Layouts perfekte Rechtecke.
4) Nehmen Sie das erste Ziegellayout heraus, das den Stabilitätskriterien entspricht
{{_,,\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
Nach diesem Schritt müssen wir nur noch das Layout ausdrucken
5) Drucken Sie das Layout
{{(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
Probieren Sie es hier online aus
82 Bytes
l~:H;{e_mrH({H-X$,+(mr)/(\e_}%_::+)-X${_,,\f<1fb}%2ew{:&,(},+,}g{{(2*'_*'[\']}/N}/
Dies ähnelt fast der 92-Byte-Version, nur dass sie etwas zufällig ist. Wenn Sie die Erklärung für die 92-Byte-Version gelesen haben, sind die Teile 3, 4 und 5 in der 82-Byte-Version genau gleich. Anstatt alle Permutationen aus Teil 1 und 2 zu durchlaufen, generiert diese Version einfach zufällig eine der folgenden Permutation zu einem Zeitpunkt, testet es mit Teil 3 und 4 und startet dann den Prozess neu, wenn die Tests von Teil 3 und 4 fehlschlagen.
Dies gibt die Ergebnisse für die ersten 3 Testfälle sehr schnell aus. Der Testfall height = 5 muss noch auf meinem Computer ausgegeben werden.
Erklärung des Unterschieds
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
Die Idee zu dieser Version stammt von randomra (Get it?)
Versuchen Sie dieses online