Rubis, 228 octets * 21895 = 4992060
->n{a=(0..n*2).map{$b=' '*n}
g=0
m=n*2
(n**0.5).to_i.downto(1){|i|n%i<1&&(m=[m,n+h=n/i].min
g+=h+1
g<m+2?(a[g-h-1,1]=(1..h).map{?**i+$b}):(x=(m-h..m).map{|j|r=a[j].rindex(?*);r ?r:0}.max
(m-h+1..m).each{|j|a[j][x+2]=?**i}))}
a}
Plusieurs changements par rapport au code non golfé. Le plus grand est le changement de signification de la variable mde la hauteur du rectangle le plus carré à la hauteur du rectangle le plus carré plus n.
Trivial, *40a été changé en *nce qui signifie beaucoup d'espace blanc inutile à droite pour les grands n; et -2est changé en 0ce qui signifie que les rectangles tracés en bas manquent toujours les deux premières colonnes (cela se traduit par un emballage moins bon pour les nombres dont la seule factorisation est (n/2)*2)
Explication
J'ai enfin trouvé le temps d'y revenir.
Pour une donnée, nle plus petit champ doit avoir suffisamment d'espace pour le rectangle le plus long 1*net le rectangle le plus carré x*y. Il doit être évident que la meilleure disposition peut être obtenue si les deux rectangles ont leurs côtés longs orientés dans la même direction.
En ignorant l'exigence d'espace blanc entre les rectangles, nous constatons que la surface totale est soit (n+y)*x = (n+n/x)*xou n*(x+1). Dans les deux cas, cela est évalué n*x + n. Y compris les espaces, nous devons inclure un supplément xsi nous plaçons les rectangles bout à bout, ou nsi nous plaçons les rectangles côte à côte. Le premier est donc préférable.
Cela donne les limites inférieures suivantes (n+y+1)*xpour la zone de champ:
n area
60 71*6=426
111 149*3=447
230 254*10=2540
400 421*20=8240
480 505*20=10100
Cela suggère l'algorithme suivant:
Find the value (n+y+1) which shall be the field height
Iterate from the squarest rectangle to the longest one
While there is space in the field height, draw each rectangle, one below the other, lined up on the left border.
When there is no more space in the field height, draw the remaining rectangles, one beside the other, along the bottom border, taking care not to overlap any of the rectangles above.
(Expand the field rightwards in the rare cases where this is necessary.)
Il est en fait possible d'obtenir tous les rectangles pour les cas de test requis dans les limites inférieures mentionnées ci-dessus, à l'exception de 60, ce qui donne la sortie 71 * 8 = 568 suivante. Cela peut être légèrement amélioré à 60 * 9 = 540 en déplaçant les deux rectangles les plus minces vers la droite, puis vers le haut, mais l'économie est minime, donc cela ne vaut probablement pas de code supplémentaire.
10
12
15
20
30
60
******
******
******
******
******
******
******
******
******
******
***** *
***** *
***** *
***** *
***** *
***** *
***** *
***** *
***** *
***** *
***** *
***** *
*
**** *
**** *
**** *
**** *
**** *
**** *
**** *
**** *
**** *
**** *
**** *
**** *
**** *
**** *
**** *
*
*** *
*** ** *
*** ** *
*** ** *
*** ** *
*** ** *
*** ** *
*** ** *
*** ** *
*** ** *
*** ** *
*** ** *
*** ** *
*** ** *
*** ** *
*** ** *
*** ** *
*** ** *
*** ** *
*** ** *
** *
** *
** *
** *
** *
** *
** *
** *
** *
** *
** *
Cela donne une superficie totale de 21895.
Code non golfé
f=->n{
a=(0..n*2).map{' '*40} #Fill an array with strings of 40 spaces
g=0 #Total height of all rectangles
m=n #Height of squarest rectangle (first guess is n)
(n**0.5).to_i.downto(1){|i|n%i<1&&(puts n/i #iterate through widths. Valid ones have n%i=0. Puts outputs heights for debugging.
m=[m,h=n/i].min #Calculate height of rectangle. On first calculation, m will be set to height of squarest rectangle.
g+=h+1 #Increment g
g<n+m+2? #if the rectangle will fit beneath the last one, against the left margin
(a[g-h-1,1]=(1..h).map{'*'*i+' '*40}) #fill the region of the array with stars
: #else
(x=(n+m-h..n+m).map{|j|r=a[j].rindex('* ');r ?r:-2}.max #find the first clear column
(n+m-h+1..n+m).each{|j|a[j][x+2]='*'*i} #and plot the rectangle along the bottom margin
)
)}
a} #return the array
puts f[gets.to_i]