Alice es pasante en una empresa que utiliza Brainfuck como idioma principal para el desarrollo tanto del lado del cliente como del lado del servidor. Alice acaba de escribir su primer código y está un poco nerviosa mientras se prepara para su primera revisión de código.

Alice quiere que su código tenga el formato correcto y se vea bien, pero no tiene tiempo para leer la guía de estilo de código de la compañía de 328 páginas, por lo que decidió formatearlo como un cuadrado perfecto . Por desgracia, la longitud del código puede ser insuficiente para formar un cuadrado, por lo que decidió dejar un espacio rectangular en el medio. Los espacios deben estar perfectamente centrados y tan cerca del cuadrado como sea posible.

Ejemplos

++++++         +++++         +++++         +++++         +++++         +++++
++++++         +++++         +++++         +  ++         ++ ++         +++++
++++++         ++ ++         +   +         +  ++         +   +
++++++         +++++         +++++         +++++         ++ ++         +++++
++++++         +++++         +++++         +++++         +++++         +++++

Perfect         OK         Acceptable   Unacceptable    No way!        Nope.

Escribe un programa o una función para ayudar a Alice. Dado el código de Alice como una cadena de entrada, emite un código formateado correctamente como se describe a continuación si es posible. Si el formateo es imposible, muestra emoji llorando :~(.

Este es el código de golf, por lo que las respuestas se puntúan en bytes con menos bytes como objetivo.

Restricciones

1. Su programa o función debe tomar una sola cadena como entrada y generar una o más líneas de texto (o devolver una cadena de varias líneas o una matriz de cadenas, si implementa una función).
2. La cadena de entrada puede contener caracteres ASCII, incluidos espacios en blanco.
3. Todos los espacios en blanco en la entrada deben ignorarse. No deben contar para la longitud del código y no deben usarse en la salida.
4. La cadena de entrada contiene al menos un carácter que no es un espacio en blanco.
5. El código formateado debe tener los mismos caracteres que no sean espacios en blanco en el mismo orden que en el código de entrada.
6. El código formateado debe ser un cuadrado perfecto, es decir, todas las líneas deben tener la misma longitud, y el número de líneas debe ser igual a la longitud de las líneas.
7. El código formateado puede contener un espacio en el medio.
8. Solo se pueden usar caracteres de espacio (código ASCII 32) en el espacio.
9. La brecha (si está presente) debe ser rectangular.
10. Cada línea de código formateado debe contener al menos un carácter que no sea un espacio en blanco, es decir, el ancho del espacio debe ser estrictamente menor que el ancho cuadrado (el espacio 5x1 es inaceptable para el cuadrado 5x5).
11. El espacio debe ser horizontal, es decir, el ancho del espacio debe ser mayor o igual que la altura del espacio.
12. La brecha debe estar perfectamente centrada.
13. En consecuencia, la paridad del ancho y la altura del espacio debe ser igual a la paridad del ancho cuadrado (por ejemplo, para un espacio cuadrado de 5x5 puede ser 1x1, 3x1 o 3x3).
14. Si es posible, salida cuadrada sin espacio en absoluto.
15. En el caso de múltiples soluciones, elija una con el espacio más cercano al cuadrado, es decir, la diferencia entre el ancho del espacio y la altura del espacio es mínima (por ejemplo: el espacio 10x10 es más preferible que 8x6, y 8x6 es más preferible que 6x2).
16. Si todavía hay un empate, elija una solución con un área de separación mínima (por ejemplo, la separación 2x2 es más preferible que 4x4).
17. Si es imposible formatear el código, salida :~(.
18. Nueva línea después de la última línea es opcional.
19. [Nuevo] Puede suponer con seguridad que cualquier personaje con código inferior a 33 es un espacio en blanco. Espero que te ayude a jugar golf.

Pruebas

Input           Output      Code length     Comment

+++++++++       +++                   9     Alice is lucky, 
                +++                         her code perfectly fits a square. 
                +++


++++++++        +++                   8     Though code length isn't enough for a square, 
                + +                         a small gap fixes it.
                +++


++++++          :~(                   6     No luck, code cannot be formatted.


Hello,          Hell                 12     Input may contain any ASCII characters, 
World!          o  ,                        but whitespaces in input should be ignored.
                W  o
                rld!


+++++ + +++++   +++++                22     Gap is not required to be a square, 
+++++ + +++++   +++++                       it can be a rectangle.
                +   +
                +++++
                +++++

+++ + +++       ++++++++             28     There exists another solution: 
+++ + +++       +      +                    6x6 square with 4x2 gap, 
+++ + +++       +      +                    but in Alice's opinion square gap 
+++ + +++       +      +                    makes code more readable.
                +      +
                +      +
                +      +
                ++++++++

Pruebas difíciles

This must be    Thism                24     7x7 with 5x5 gap looks good,
5x5 with 1x1    ustbe                       but 5x5 with 1x1 gap is better,
gap.            5x 5w                       because gap area is smaller.
                ith1x
                1gap.

+++ +++ +++     :~(                  18     In case you tried 5x5 square
+++ +++ +++                                 with 7x1 gap ;)

Recursos

Para ahorrar espacio, puede encontrar código de muestra y casos de prueba adicionales en tio.run

[Nuevo] Puede echar un vistazo a la tabla de soluciones aceptadas para entradas de hasta 100 caracteres . Cambié ancho y alto porque parece parecer más intuitivo.

Inspirado en: un cuadrado de texto

Cambios

• Se agregaron 2 pruebas, se corrigió el error en el código de muestra.

• Se agregó una tabla de soluciones hasta 100, se agregó una aclaración de espacios en blanco.

C (gcc) , 354 bytes

h,i,j,k,l,m;g,v,w,d;f(char*s){for(i=l=0;s[i];l+=!isspace(s[i++]));d=g=l;for(i=0;i++<l;)if(h=i*i-l)for(j=0;j<i-++j;h>0&h%k<1&k<=m&m<i&m+~k&&m-k<g|m==k+g&(d-2*v)*(d-2*w)>h?w=(i-m)/2,v=j,g=m-k,d=i:j)k=i-2*j,m=h/k;else g=0,v=w=d=i;if(g-l)for(i=j=1;*s;j+=!i++,k=0,i%=d+1)for(putchar(i?v>=j|j>d-v|w>=i|i>d-w?k=1,*s:32:10);k;k*=isspace(*++s));else puts(":~(");}

Pruébalo en línea!

JavaScript (ES6),  284 ... 274  270 bytes

Guardado 4 bytes gracias a @Shaggy

Devuelve una matriz de cadenas.

s=>(s=s.replace(/\s/g,''),n=s.length,o=[':~('],W=d=g=(x,w=0,h=p=0)=>4*~-x>n?o:h>w?++w>x-2?g(-~x):g(x,w):g(x,w,h+1,o=n-x*x+w*h|(w^x|h^x)&!!(w|h)|w-h>d|w-h==d&w>W?o:[...Array(x)].map((_,Y,a)=>a.map((_,X)=>2*X>=x-w&2*X<x+w&2*Y>=x-h&2*Y<x+h?' ':s[p++]).join``,d=w-h,W=w)))``

Pruébalo en línea!

Stax , 80 bytes

ö╦Çc▀╕╡ëé╓]µiÖ9♪`W|╣▐↑╖D┘↕♫╗╔äƒ■úφ■U`ÿ⌠%é┴☼vAú)☺@ı◄¬¶¢(îÉ┼6⌠D~♀└lfæA.I@º╤∟òîü╦(

Ejecutar y depurarlo

¿Como funciona?

• Considere todos los cuadrados con recortes rectangulares.
• Filtre formas de programa que no sean del tamaño correcto.
• Filtre formas de programa que no tienen paridad coincidente.
• Filtre las formas del programa donde el recorte es demasiado grande para el cuadrado.
• Si no se encuentra ninguno, falla la salida y se cierra.
• Encuentre la forma que minimiza la "rectangularidad" del recorte, luego por el tamaño del recorte.
• Reemplace cada carácter en la forma del programa con el carácter correspondiente en la entrada del programa.

Desempaquetado, sin golf, y comentó que se ve así.

                input e.g. "big socks"
L$j$            remove whitespace from input e.g. "bigsocks"
cr{~F           copy push each remaining character to input stack in reverse order
%c              get length L of flattened input and copy e.g. 8
^r3:$           create triples [a,b,c] in range 0..n e.g. [[0,0,0], [0,0,1], ... [8,8,8]]
{E*NsJ+n=f      filter triples: require a*a-b*c=L e.g. [[3,1,1], [4,1,8], ...]
{ET>f           filter triples: a>b and a>c e.g. [[3,1,1]]
{{2%m:u_0#+f    filter triples: a%2=b%2=c%2 or b*c=0 e.g. [[3,1,1]]
":~("s|c        if there are no triples, output ":~(" and terminate
{D:s_D:*\oh     sort by [abs(b-c),b*c]; keep the first e.g. [3,1,1]
X               store the chosen triple in the X register
E               explode onto stack e.g. 3, 1, 1
z)]*            using last two values, make a rectangle of zeroes e.g. 3, [[0]]
~               this will be the cutout, push it to the input stack
c'X*]*          make a square of "X" e.g. ["XXX", "XXX", "XXX"]
xEd-h           given the dimensions in x register, calculate the centered cutout coordinates
xEsd-h          e.g. ["XXX", "XXX", "XXX"], 1, 1
,||             embed the cutout grid at the specified coordinates e.g. ["XXX", "X X", "XXX"]
m'X{,]}R        for each line, regex replace "X" with a character from the input stack

Ejecute este

Carbón , 120 bytes

≔Ｅ⮌⪫⪪Ｓ ωιθ≔⁰ηＦ⊕Ｌθ¿⁼Ｌθ×ιι«≔ιη≔ιζ≔ιε»Ｆ⊘ιＦ⊕κＦ∧⁼Ｌθ⁻×ιι×⁻ι⊗⊕κ⁻ι⊗⊕λ∨¬η›⁻ζε⁻κλ«≔ιη≔⊕κζ≔⊕λε»¿η«ＵＯη#ＪεζＦ›η⊗ζＵＯ⁻η⊗ε⁻η⊗ζψＵＭＫＡ⊟θ»:~(

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

≔Ｅ⮌⪫⪪Ｓ ωιθ

Elimine los espacios de la entrada, luego inviértalo y divídalo en caracteres, para que podamos recorrer los caracteres más fácilmente más adelante.

≔⁰η

Comience con un tamaño de cero, lo que indica que no se encontró ningún resultado (todavía).

Ｆ⊕Ｌθ

Verifique todas las longitudes laterales hasta la longitud de la cuerda. (Lanzar una división en, por supuesto, haría que el código sea más rápido).

¿⁼Ｌθ×ιι«≔ιη≔ιζ≔ιε»

Si el resultado resulta ser un cuadrado perfecto, guarde el tamaño del cuadrado y también configúrelo como el tamaño del borde.

Ｆ⊘ιＦ⊕κ

Pase sobre las posibles alturas y anchos del borde (el ancho del borde no es mayor que la altura del borde, lo que hace que la altura del espacio no sea mayor que el ancho del espacio).

Ｆ∧⁼Ｌθ⁻×ιι×⁻ι⊗⊕κ⁻ι⊗⊕λ∨¬η›⁻ζε⁻κλ«≔ιη≔⊕κζ≔⊕λε»

Si el tamaño del borde es la longitud deseada y todavía no tenemos una solución o no es tan cuadrada como esta solución, actualice la solución con este tamaño de cuadrado y borde.

¿η«

Si tenemos una solución ...

ＵＯη#

Dibuja un rectángulo de un carácter arbitrario del tamaño cuadrado dado.

ＪεζＦ›η⊗ζＵＯ⁻η⊗ε⁻η⊗ζψ

Si el borde es lo suficientemente pequeño como para dejar un espacio, borre el espacio. (El comando de dibujo dibujará hacia arriba y hacia la izquierda para valores negativos y no le gustan los valores cero).

ＵＭＫＡ⊟θ

Reemplace todos los caracteres (restantes) con caracteres de la entrada.

»:~(

De lo contrario salida :~(.

Jalea , 91 85 bytes

ÆDżU$<Ạa;ḂEɗʋƇṢƑƇ;€€
ḟ⁶ḟ⁷;©⁶L’²<¥Ðḟ²_ç;,`Wɗ¹?⁸ʋ€$Ẏạ/ÞḢµIH+""Rp"/ḟ@/ŒṬ€ĖP€Sị®Yµ“:~(”¹?

Pruébalo en línea!

Un enlace monádico que toma la cadena de entrada como argumento y devuelve una cadena con la salida formateada o :~(.

Python 2, 287 281 279 bytes

c=list("".join(input().split()))
l=len(c)
p=[]
for q in range(l*l):x=q%l;y=q/l;s=(l+x*y)**.5;p+=[(abs(x-y)/2,int(s),-x)]*(s%1==0)*(x<s-1>y>=s%2==x%2==y%2or x<1)
if p:d,s,x=min(p);b=(s+x)/2;Y=0;exec"c[b:b]=' '*-x*(b+d<=Y<s-b-d);print''.join(c[:s]);c=c[s:];Y+=1;"*s
else:print':~('

Pruébalo en línea!

Utiliza la comparación de listas lexicográficas de Python utilizando los mismos valores para elegir una solución e imprimirla. Estoy bastante seguro de que 10 4 2 o menos bytes aún se pueden eliminar.

Explicación

c=list("".join(input().split()))
l=len(c)
p=[]

Elimine los espacios en blanco dividiéndolos con espacios en blanco y uniéndolos "", luego convierta la entrada en una lista para más adelante. Inicialice también la llongitud del código real y la plista de posibilidades válidas.

for q in range(l*l):x=q%l;y=q/l;s=(l+x*y)**.5;

Recorre todas las posibilidades de tamaños de espacio desde 0*0hasta l*l. Calcule la longitud del borde del cuadrado con lcaracteres de código y x*yespacios como s.

p+=[(abs(x-y)/2,int(s),-x)]*(s%1==0)*(x<s-1>y>=s%2==x%2==y%2or x<1)

Compruebe si las siguientes condiciones coinciden:

• s % 1 == 0, es decir, se formaría un cuadrado perfecto
• x < s-1 > y, es decir, xy yestán como máximo s-2y caben dentro del cuadrado
• s % 2 == x % 2 == y % 2, es decir, ambos xyy que coincida con la paridad del borde y puede ser centrada
• pero si x < 1, es decir x == 0, ignora todo menos el requisito de cuadrado perfecto

Si las condiciones coinciden, agregue los siguientes elementos en una tupla ppara encontrar el óptimo:

• abs(x-y)/2; Primero encuentre la diferencia mínima de xy ypara obtener la mayor brecha cuadrada. Esto siempre es así, así que dividimos por 2.
• int(s); luego encuentre la longitud lateral mínima. Como ses un número entero y aumenta a medida que el área de separación x*y, esto se ordena por área de separación.
• -x; luego encuentre el ancho máximo para preferir espacios horizontales. Esto viene después del área debido a cómo se desarrolló, pero el área es la misma x*yy y*xfunciona.

if p:d,s,x=min(p);b=(s+x)/2;Y=0

Si encontramos diseños válidos, encuentre el óptimo como se describió anteriormente. Calcule el borde horizontal be inicialice el número de línea Ya 0.

exec"c[b:b]=' '*-x*(b+d<=Y<s-b-d);print''.join(c[:s]);c=c[s:];Y+=1;"*s

Si el número de línea Yestá dentro del espacio (el borde vertical es b+d, con dla tupla), agregue el espacio de ancho del espacio después del borde horizontal c. (La modificación de ces por qué necesitamos que sea una lista.) Luego imprima una línea del cuadrado y quítela c. Repita los stiempos, incrementando el número de línea.

else:print':~('

Si no se encontraron diseños, falle.

Pyth , 99 98 bytes

#JscQ)=QshKh|oaFtNSf!|%hT1&eT|t{%R2TgeStThT+L@+lJ*Fd2^UJ2
":~("Am/-Qd2tKW=W}~hZrG-QGJj*eKdcJ]H<~>J

Pruébalo en línea!

Esto usa el mismo algoritmo que mi respuesta de Python, pero muchos detalles se cambian significativamente para ser más cortos en Pyth.

Pyth muestra su antigüedad aquí, ya que no se ha actualizado en edades y solo usa los caracteres ASCII imprimibles (para código, no datos), desperdiciando mucho espacio.

Curiosamente, si Pyth usara el mismo tipo de empaque de base 256 que Stax, este programa podría ser ⌈98 log ₂₅₆ 95⌉ = 81 bytes de largo, justo al lado de Stax (80 bytes) y Jelly (85 bytes). Creo que esto muestra muy bien cuán cercanos están los lenguajes de golf incluso con sus paradigmas drásticamente diferentes.

Explicación (solo un poco menos ilegible que el código)

#envuelve todo en un while True:que suprime el mensaje y se cierra por error.

JscQ) csalta input ( Q) en el espacio en blanco, sune las partes y guarda el resultado en J.

^UJ2hace la lista de índices ( U) de Jy toma su 2poder cartesiano nd ( ^), dando como resultado todos los pares [h,w]con 0<=h<len(J)y 0<=w<len(J).

+L@+lJ*Fd: para todos ( L) tales pares d, agrega ( +) la raíz cuadrada ( @... 2) de (la lprofundidad de Jmás ( +) el producto ( *F) del par d) al lado izquierdo del par, creando un triplete [side length, gap height, gap width].

f!|%hT1&eT|t{%R2TgeStThT: filter para trillizos Tdonde

• ninguno de ( !|):
  • longitud lateral ( hT) módulo 1 ( %... 1) no es cero
  • ambos de ( &):
    • la altura del espacio ( eT) no es cero
    • cualquiera de ( |):
      • cada número en el triplete ( R) módulo 2 ( %... 2), con duplicados ( {) y el primer único ( t) eliminado, no está vacío
      • el mayor ( eS) de la altura del espacio y el ancho del espacio ( tT) es gmás o menos igual que la longitud del lado ( hT)

Sclasifica los trillizos lexicográficamente (por la longitud del lado, luego por la altura del espacio). oaFtNluego oclasifica los tripletes por la adiferencia de solutos entre la altura del espacio y el ancho del espacio ( tN).

En este punto, si no tenemos soluciones válidas, |evalúa su segundo argumento \n":~(", que imprime y devuelve :~(. htoma la solución óptima (o ":"si no hay ninguna) y se guarda en K. Luego htoma su longitud lateral (o ":"si no hay ninguno), lo sconvierte en entero (o falla y se cierra si no hay ninguno) y se guarda ( =) enQ .

Cada uno de ( m) [gap height, gap width]( tK) se resta ( -) de la longitud del lado ( Q) y el resultado se divide por 2 ( /... 2). Los resultados se Aasignan a Gy H.

Finalmente, entramos en un Wbucle hile. Zcomienza en 0 y cada iteración lo incrementamos pero usamos el valor anterior ( ~hZ, piense Z++en C).

• Si ( W) el valor anterior está en ( {) el rángulo Ga (longitud lateral - G) ( -QG), asigne ( =) a Jlo siguiente: csalte Ja la posición ( ]) Hy jalinee las mitades con el ancho del espacio eKmultiplicado por ( *) un espacio ( d). Si el valor no estaba en el rango, solo regrese J. Si este resultado está vacío, detenga el ciclo.
• Elimine ( >) los primeros Qcaracteres de Jy asigne ( ~) el resultado a J. Del valor anterior de J, tome ( <) los primeros Qcaracteres e imprímalos.

Finalmente, el #ciclo comienza de nuevo, errores y se cierra porque cQ)al Qcontener un número no es válido.

05AB1E , 95 89 bytes

… 
    мDg©Ý3ãʒćnsP-®Q}ʒć‹P}ʒÈËyß_~}Dg_i…:~(ëΣ¦DÆÄsP‚}н©¤_iнë¬Uć᤮Ås<иs;R`X*+šXnª£®θð×ýX}ô»

Unos pocos bytes aquí y allá definitivamente se pueden jugar al golf.

Los primeros tres pasos del programa están inspirados en la respuesta Stax de @recursive , ¡así que asegúrese de votarlo!

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

Paso 1: elimine todos los espacios en blanco:

… 
                   # Push string " \n\t"
    м              # And remove those from the (implicit) input-string

Paso 2: crea todos los trillizos posibles $[a,b,c]$, dónde $a$ es la dimensión del resultado $a×a$ cuadrado y $b×c$es el tamaño de la brecha Hacemos esto creando todos los tripletes posibles usando enteros en el rango$[0,a]$. Y luego filtramos estos donde todo lo siguiente es verdadero para el triplete:

• $a^2-b×c=L$, dónde $L$ es la longitud de la cuerda
• $(a\gt b)\text{ and }(a\gt c)$
• $(a\pmod2=b\pmod2=c\pmod2)\text{ or }(min(a,b)\neq0)$

Por ejemplo: $L=28$resultará en los trillizos [[6,2,4],[6,4,2],[8,6,6]].

Dg                 # Get the length of this string (without popping by duplicating first)
  ©                # Store this length in variable `®` (without popping)
   Ý               # Create a list in the range [0,®]
    3ã             # Create all possible triplets by repeating the cartesian product 3 times
ʒ                  # Filter these triplets by:
 ć                 #  Extract head; pop and push remainder-list and head to the stack
  n                #  Square the head
   sP-             #  Take the product of the remainder, and subtract it from the squared head
      ®Q           #  And check if it's equal to the string length in variable `®`
}ʒ                 # Filter the remaining triplets further by:
  ć‹P              #  Where the first integer is larger than the other two
}ʒ      }          # And filter it a third time by:
  ÈË               #  Where all three are either odd or even
       ~           #  Or
    yß_            #  It does not contain any 0s

Paso 3: Comprueba si todavía nos quedan tresillos. Si no, salida ":~("; si lo hacemos, determine cuál usar clasificando y dejando solo el primero. Hacemos esto clasificando las tuplas$(abs(b-c),b×c)$.

Por ejemplo: los trillizos [[6,2,4],[6,4,2],[8,6,6]]se ordenarán [[8,6,6],[6,2,4],[6,4,2]], después de lo cual solo [8,6,6]permanecerá.

Dg_i               # If this completely filtered list is now empty:
    …:~(           #  Push string ":~("
ë                  # Else:
 Σ                 #  Sort the triplets by:
  ¦                #   Remove the first character
   DÆÄ             #   Get the absolute difference between the remaining two integers
   sP‚             #   And pair it with the product of the remaining two integers
      }н           #  After we're done sorting: only leave the first triplet

Paso 4: crea una lista sobre cómo debemos dividir la cadena para insertar los espacios. Esto se hace así:

Dado $[a,b,c]$, cree una lista con:

• Como primer artículo: $\frac{a-b}{2}×a + \frac{a-c}{2}$
• Como medio $b-1$ artículos: ${a-c}$
• Como último artículo: $a^2$

Por ejemplo: triplete [7,3,5]dará como resultado la lista [15,2,2,35].

©                  #  Store this triplet in variable `®` (without popping)
 ¤_i               #  If the last value is 0 (which means the string is a square without gap):
    н              #   Simply keep the first value of the triplet
   ë               #  Else:
    ¬U             #   Store the first value in variable `X` (without popping)
      ć            #   Extract the first value; pop and push remainder-list and head to the stack
       α           #   Get the absolute difference of this head with the other two values
        ¤          #   Push the last value (without popping the pair itself)
         ®Ås<и     #   And repeat it the middle element or `®` minus 1 amount of times
       s           #   Swap to get the difference pair again
        ;          #   Halve both values
         R`        #   Push them reversed to the stack
           X*      #   Multiple the first value by `X`
             +     #   And then add it to the second value
              š    #   Prepend this in front of the repeated list
               Xnª #   And also append the square of `X`

Paso 5: Y finalmente dividimos la cadena en función de esta lista, únala nuevamente con $c$ cantidad de espacios, dividirlo en partes de tamaño $c$, y únete a ellos por nuevas líneas. Por ejemplo:

Cadena "Alongtesttoseeifitworksasintended."dividido de acuerdo a la lista [15,2,2,35]resultará en: ["Alongtesttoseei","fi","tw","orksasintended."]. Esto luego se une por$c=5$cantidad de espacios para "Alongtesttoseei fi tw orksasintended.". Y luego dividir en partes de tamaño$a=7$a esto: ["Alongte","sttosee","i f","i t","w o","rksasin","tended."]. Que luego se une con nuevas líneas a la salida.

    £              #   Then split the string into parts based on this list
     ®θð×          #   Push a string consisting of the last value of `®` amount of spaces
         ý         #   Join the list of substrings by this
          X        #   Push variable `X`
   }ô              #  After the if-else: split the string into parts of that size
     »             #  And then join these by newlines
                   # (after which the top of the stack is output implicitly as result)