sfondo

Ho un sacco di scatole quadrate di uguali dimensioni e, dato che sono una persona ordinata, voglio sistemarle tutte in una formazione quadrata. Tuttavia, il loro numero non è necessariamente un quadrato perfetto, quindi potrei dover approssimare la forma quadrata. Voglio che tu mi trovi la sistemazione esteticamente più piacevole - programmaticamente, ovviamente.

Ingresso

Il tuo input è un singolo intero positivo k, che rappresenta il numero di caselle.

Produzione

Il tuo programma sceglierà due numeri interi positivi m, nche m*(n-1) < k ≤ m*nvalgono. Rappresentano la larghezza e l'altezza della grande forma quadrata che stiamo organizzando. Poiché stiamo cercando forme esteticamente gradevoli, la quantità deve essere minima, in modo che la forma sia vicina a un quadrato e la sua area sia vicina . Se ci sono ancora diversi candidati per la coppia , scegli quello in cui la larghezza è massima.(m - n)2 + (m*n - k)2k(m, n)m

Ora, l'output effettivo non deve essere i numeri me n. Invece, dovrai stampare la disposizione delle scatole, usando il personaggio #per rappresentare una scatola. Più specificamente, dovrai stampare n-1righe, ognuna delle quali è composta da mcaratteri #, quindi una riga di k - m*(n-1)caratteri #. Si noti che l'output contiene esattamente kcaratteri #.

Regole e punteggio

Non devono esserci spazi bianchi iniziali o finali nell'output, tranne che l'ultima riga può essere riempita con spazi finali di lunghezza m, se desiderato. Potrebbe esserci una nuova riga finale, ma nessuna riga precedente. È possibile utilizzare qualsiasi carattere ASCII stampabile al posto di #, se lo si desidera.

È possibile scrivere un programma completo o restituire una stringa da una funzione. Vince il conteggio di byte più basso e non sono consentite scappatoie standard.

Casi test

Ecco gli output corretti per alcuni valori di input.

1
#
2
##
3
##
#
4
##
##
8
###
###
##
13
#####
#####
###
17
######
######
#####
18
#####
#####
#####
###
20
#####
#####
#####
#####
21
######
######
######
###
22
######
######
######
####
23
#####
#####
#####
#####
###

Pyth, 28 byte

jbc*\#Qho.a,,N*NJ_/_QN,JQ_SQ

Provalo online.

Il punto cruciale è che ordino il potenziale m sulla seguente proprietà:

(m - ceil(k/m))^2 + (m*ceil(k/m) - k)^2

Si noti l'assenza totale di n. La forma totale è definita semplicemente da m. Quindi trasformo ancora una volta la proprietà sopra e il mio peso di smistamento finale è definito come la distanza euclidea tra i seguenti due punti:

(m, m*ceil(k/m)) and (ceil(k/m), k)

Ciò modifica i valori di peso, ma non il loro ordine.

Python 3, 202 byte

So che è più lungo delle soluzioni CJam o Pyth, ma tuttavia, ecco un modo per risolvere questo problema in Python:

k=int(input())
r,d,s=range(k+1),{},'#'*k
for n in r:
 for m in r:
  if m*n>=k:
   d[m,n]=(m-n)**2+(m*n-k)**2
x,y=max(i for i in d.keys()if d[i]==min(d.values()))
[print(s[i*x:(i*x+x])for i in range(y+1)]

Il principio di base è che sappiamo che m e n sono entrambi inferiori a k. Inoltre, m * n> = k. Ciò significa che possiamo semplicemente trovare il minimo dell'espressione data nella sfida per tutti m, n <k, esclusi i valori il cui prodotto è maggiore di k.

CJam ( 44 42 byte)

qi_,{)_2$d\/m]_2$-_*@@*2$-_*+~}$W=)'#@*/N*

Demo online

Mi aspettavo piuttosto che ci fosse una soluzione più semplice che coinvolgesse le radici quadrate, ma non è affatto così semplice. Ad esempio per l'ingresso 31la larghezza della riga è due maggiore del soffitto della radice quadrata; per 273(radice quadrata poco più di 16,5) il miglior quadrato approssimativo è un rettangolo 21x13 perfetto.

CJam, 42 byte

li:K_,f-{:XdK\/m]:YX-_*XY*K-_*+}$0='#K*/N*

Provalo online

Spiegazione:

li    Get and interpret input.
:K    Store in variable K for later use.
_     Copy.
,     Build sequence [0 .. K-1].
f-    Subtract from K, to get sequence [K .. 1]. Larger values have to come
      first so that they are ahead in ties when we sort later.
{     Begin block for calculation of target function for sort.
  :X    Store width in variable X.
  d     Convert to double.
  K\/   Calculate K/X.
  m]    Ceiling.
  :Y    Store height in variable Y.
  X-    Calculate Y-X.
  _*    Square it.
  XY*   Calculate X*Y...
  K-    ... and X*Y-K
  _*    Square it.
  +     Add the two squares.
}$    Sort by target function value.
0=    Get first element, this is the best width.
'#K*  Build string of K '# characters.
/     Split using width.
N*    Join with newlines.