Antecedentes

Tengo un montón de cajas cuadradas de igual tamaño, y como soy una persona ordenada, quiero organizarlas todas en una formación cuadrada. Sin embargo, su número no es necesariamente un cuadrado perfecto, por lo que es posible que tenga que aproximar la forma cuadrada. Quiero que me encuentres el arreglo más estéticamente agradable, programáticamente, por supuesto.

Entrada

Su entrada es un solo entero positivo k, que representa el número de cuadros.

Salida

Su programa elegirá dos enteros positivos m, ntales que se m*(n-1) < k ≤ m*nmantengan. Representan el ancho y la altura de la gran forma cuadrada que estamos organizando. Como estamos buscando formas estéticamente agradables, la cantidad será mínima, de modo que la forma esté cerca de un cuadrado y su área esté cerca . Si todavía hay varios candidatos para el par , elija el que tenga el ancho máximo.(m - n)² + (m*n - k)²k(m, n)m

Ahora, su salida real no será los números my n. En su lugar, deberá imprimir la disposición de las cajas, utilizando el carácter #para representar una caja. Más específicamente, deberá imprimir n-1filas, cada una de las cuales consta de mcaracteres #, y luego una fila de k - m*(n-1)caracteres #. Tenga en cuenta que la salida contiene exactamente kcaracteres #.

Reglas y puntuación

No habrá espacios en blanco iniciales o finales en la salida, excepto que la última fila puede rellenarse con espacios finales para ser de longitud m, si se desea. Puede haber una nueva línea final, pero no nuevas líneas anteriores. Puede usar cualquier carácter ASCII imprimible en lugar de #, si lo desea.

Puede escribir un programa completo o devolver una cadena de una función. El conteo de bytes más bajo gana, y las lagunas estándar no se permiten.

Casos de prueba

Aquí están las salidas correctas para algunos valores de entrada.

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

code-golf ascii-art optimization

— Zgarb
fuente

6

Pyth, 28 bytes

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

Pruébalo en línea.

El quid es que clasifico m potencial en la siguiente propiedad:

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

Tenga en cuenta la ausencia total de n. La forma total se define simplemente por m. Luego transformo la propiedad anterior una vez más, y mi peso de clasificación final se define como la distancia euclidiana entre los siguientes dos puntos:

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

Esto cambia los valores de peso, pero no su orden.

— orlp
fuente

3

Python 3, 202 bytes

Sé que es más largo que las soluciones CJam o Pyth, pero sin embargo, aquí hay una forma de resolver este problema en 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)]

El principio básico es que sabemos que myn son ambos menores que k. Además, m * n> = k. Eso significa que simplemente podemos encontrar el mínimo de la expresión dada en el desafío para todos m, n <k, excluyendo valores cuyo producto es mayor que k.

— Anthony Roitman
fuente

De hecho, cuento 231 bytes en su fuente, no 234. Pero independientemente, puede reducirlo disminuyendo el tamaño de su sangría de cuatro espacios a un espacio. Funcionará igual.

— Alex A.

Esta es una herramienta útil para obtener el recuento de bytes. Por cierto, buena presentación y bienvenido al sitio.

— Alex A.

:falta en la línea 5. La coma es lo que define una tupla, los corchetes ()se pueden quitar en la línea 6. Los espacios entre )y ( ifo for) también. maxpuede obtener generador como parámetro, por lo tanto, los corchetes []son redundantes. Usted itera sobre las dteclas, por lo que puede usarlo de manera segura d[i].

— Trang Oul

Puede guardar dos bytes cambiando (i+1)*xa -~i*xo i*x+x.

— Kade

Tienes un par adicional no válido en (i*x+x...

— FlipTack

2

CJam ( 44 42 bytes)

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

Demostración en línea

Más bien esperaba que hubiera una solución más simple que involucrara raíces cuadradas, pero no es tan simple. Por ejemplo, para la entrada, 31el ancho de la fila es dos veces mayor que el techo de la raíz cuadrada; para 273(raíz cuadrada de poco más de 16.5) el mejor cuadrado aproximado es un rectángulo perfecto de 21x13.

— Peter Taylor
fuente

1

CJam, 42 bytes

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

Pruébalo en línea

Explicación:

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.

— Reto Koradi
fuente

Formación cuadrada aproximada