Alice é estagiária em uma empresa que usa o Brainfuck como idioma principal para o desenvolvimento do lado do cliente e do servidor. Alice acabou de escrever seu primeiro código e está um pouco nervosa ao se preparar para sua primeira revisão de código.

Alice deseja que seu código seja formatado adequadamente e tenha uma boa aparência, mas ela não tem tempo para ler o guia de estilo da empresa com 328 páginas, então decidiu formatá-lo como um quadrado perfeito . Infelizmente, o tamanho do código pode ser insuficiente para formar um quadrado, então ela decidiu deixar um espaço retangular no meio. As folgas devem estar perfeitamente centralizadas e o mais próximo possível do quadrado .

Exemplos

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

Perfect         OK         Acceptable   Unacceptable    No way!        Nope.

Escreva um programa ou uma função para ajudar Alice. Dado o código de Alice como uma sequência de entrada, imprima o código formatado corretamente, conforme descrito abaixo, se possível. Se a formatação for impossível, emita chorando emoji:~( .

Isso é código-golfe então as respostas são pontuadas em bytes, com menos bytes sendo o objetivo.

Restrições

1. Seu programa ou função deve usar uma única seqüência de caracteres como entrada e gerar uma ou mais linhas de texto (ou retornar uma sequência de linhas múltiplas ou um conjunto de seqüências de caracteres, se você implementar uma função).
2. A sequência de entrada pode conter caracteres ASCII, incluindo espaços em branco.
3. Todos os espaços em branco na entrada devem ser ignorados. Eles não devem contar para o comprimento do código e não devem ser usados ​​na saída.
4. A sequência de entrada contém pelo menos um caractere que não é um espaço em branco.
5. O código formatado deve ter os mesmos caracteres que não sejam espaços em branco na mesma ordem que no código de entrada.
6. O código formatado deve ser um quadrado perfeito, ou seja, todas as linhas devem ter o mesmo comprimento e o número de linhas deve ser igual ao comprimento das linhas.
7. O código formatado pode conter uma lacuna no meio.
8. Somente caracteres de espaço (código ASCII 32) podem ser usados ​​na lacuna.
9. A folga (se presente) deve ser retangular.
10. Toda linha de código formatado deve conter pelo menos um caractere que não seja um espaço em branco, ou seja, a largura do espaço deve ser estritamente menor que o quadrado (o espaço 5x1 é inaceitável para o quadrado 5x5).
11. O espaço deve ser horizontal, ou seja, a largura do espaço deve ser maior ou igual à altura do espaço.
12. O espaço deve estar perfeitamente centrado.
13. Conseqüentemente, a paridade de largura e altura da lacuna deve ser igual à paridade de largura quadrada (por exemplo, para a diferença quadrada de 5x5 pode ser 1x1, 3x1 ou 3x3).
14. Se possível, produza um quadrado sem folga.
15. No caso de várias soluções, escolha uma com a folga mais próxima do quadrado, ou seja, a diferença entre a largura e a altura da folga é mínima (por exemplo: a folga 10x10 é mais preferível que 8x6 e 8x6 é mais preferível que 6x2).
16. Se ainda houver um empate, escolha a solução com uma área de espaço mínima (por exemplo, o espaço 2x2 é mais preferível que 4x4).
17. Se for impossível formatar o código, faça a saída :~(.
18. Nova linha após a última linha é opcional.
19. [Novo] Você pode assumir com segurança que qualquer caractere com código abaixo de 33 é um espaço em branco. Espero que ajude você a jogar golfe.

Testes

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.
                +      +
                +      +
                +      +
                ++++++++

Testes complicados

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 economizar espaço, você pode encontrar código de amostra e casos de teste extras no tio.run

[Novo] Você pode dar uma olhada na tabela de soluções aceitas para entradas com até 100 caracteres . Troquei a largura e a altura porque parece mais intuição.

Inspirado por: Um quadrado de texto

Alterar

• Adicionados 2 testes, bug corrigido no código de amostra.

• Tabela de soluções adicionada até 100, clarificação de espaço em branco adicionada.

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(":~(");}

Experimente online!

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

Guardado 4 bytes graças a @Shaggy

Retorna uma matriz de seqüências de caracteres.

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)))``

Experimente online!

Stax , 80 bytes

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

Execute e depure

Como funciona?

• Considere todos os quadrados com recortes retangulares.
• Filtre as formas do programa que não são do tamanho certo.
• Filtre as formas do programa que não possuem paridade correspondente.
• Filtre as formas do programa em que o recorte é muito grande para o quadrado.
• Se nenhum for encontrado, a saída falha e sai.
• Encontre a forma que minimiza a "retangularidade" do recorte e, em seguida, pelo tamanho do recorte.
• Substitua cada caractere na forma do programa pelo caractere correspondente na entrada do programa.

Descompactado, não jogado e comentou que é assim.

                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

Execute este

Carvão vegetal , 120 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

≔Ｅ⮌⪫⪪Ｓ ωιθ

Retire os espaços da entrada, inverta-os e divida-os em caracteres, para que possamos repetir os caracteres mais facilmente mais tarde.

≔⁰η

Comece com um tamanho de zero, indicando que nenhum resultado foi encontrado (ainda).

Ｆ⊕Ｌθ

Verifique todos os comprimentos laterais até o comprimento da corda. (Jogar uma divisão certamente tornaria o código mais rápido.)

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

Se o resultado for um quadrado perfeito, salve o tamanho do quadrado e defina-o como o tamanho da borda.

Ｆ⊘ιＦ⊕κ

Faça um loop sobre as possíveis alturas e larguras da borda (a largura da borda não é maior que a altura da borda, tornando a altura da abertura não maior que a largura da abertura).

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

Se o tamanho da borda é o comprimento desejado e ainda não temos uma solução ou não é tão quadrado quanto essa solução, atualize a solução com esses tamanhos de quadrado e borda.

¿η«

Se temos uma solução ...

ＵＯη#

Desenhe um retângulo de um caractere arbitrário do tamanho quadrado especificado.

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

Se a borda for pequena o suficiente para deixar um espaço, apague-o. (O comando de desenho será desenhado para cima e para a esquerda para valores negativos e não gosta de valores zero.)

ＵＭＫＡ⊟θ

Substitua todos os caracteres (restantes) pelos caracteres da entrada.

»:~(

Caso contrário, saída :~(.

Geléia , 91 85 bytes

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

Experimente online!

Um link monádico que pega a sequência de entrada como argumento e retorna uma sequência com a saída formatada ou :~(.

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':~('

Experimente online!

Usa a comparação de lista lexicográfica do Python usando os mesmos valores para escolher uma solução e imprimi-la. Tenho certeza de que 10 4 2 ou mais bytes ainda podem ser removidos.

Explicação

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

Remova os espaços em branco dividindo com espaços em branco e juntando-se a eles "", e depois converta a entrada em uma lista para mais tarde. Inicialize também o lcomprimento do código real e pa lista de possibilidades válidas.

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

Percorra todas as possibilidades de tamanhos de espaço de 0*0até l*l. Calcule o comprimento da borda do quadrado com lcaracteres e x*yespaços de código 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)

Verifique se as seguintes condições correspondem:

• s % 1 == 0, ou seja, um quadrado perfeito seria formado
• x < s-1 > y, Ou seja, xe ysão, no máximo, s-2e se encaixam dentro do quadrado
• s % 2 == x % 2 == y % 2, ou seja, ambos x e ycoincidem com a paridade da borda e podem ser centralizados
• mas se x < 1, iex == 0 , ignorar todos, exceto o requisito quadrado perfeito

Se as condições corresponderem, adicione os seguintes itens em uma tupla ppara encontrar o melhor:

• abs(x-y)/2; primeiro encontre a diferença mínima de xey obtenha a diferença mais quadrada. Isso é sempre assim, então dividimos por 2.
• int(s); Em seguida, encontre o comprimento mínimo do lado. Como sé um número inteiro e aumenta à medida que a área do intervalox*y , ele é classificado por área do espaço.
• -x; em seguida, encontre a largura máxima para preferir espaços horizontais. Isso ocorre após a área devido à forma como foi desenvolvido, mas a área é a mesma x*ye, y*xportanto, funciona.

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

Se encontramos layouts válidos, encontre o ideal, conforme descrito acima. Calcule a borda horizontal be inicialize o número da linha Ypara 0.

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

Se o número da linha Yestiver dentro do espaço (a borda vertical é b+d, com a dpartir da tupla), adicione o valor da largura do espaço em espaços após a borda horizontal c. (A modificação de cé por isso que precisamos que seja uma lista.) Em seguida, imprima uma linha do quadrado e remova-a de c. Repita os stempos, incrementando o número da linha.

else:print':~('

Se nenhum layout for encontrado, falhe.

Pitão , 99 98 bytes

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

Experimente online!

Isso usa o mesmo algoritmo da minha resposta Python, mas muitos detalhes são alterados significativamente para serem mais curtos no Pyth.

O Pyth mostra sua idade aqui, pois não é atualizado há muito tempo e usa apenas os caracteres ASCII imprimíveis (para código, não para dados), desperdiçando muito espaço.

Curiosamente, se Pyth usasse o mesmo tipo de embalagem base-256 que a Stax, esse programa poderia ser 98 log ₂₅₆ 95⌉ = 81 bytes de comprimento, próximo a Stax (80 bytes) e Jelly (85 bytes). Eu acho que isso mostra muito bem quão próximas as línguas do golfe estão, mesmo com seus paradigmas drasticamente diferentes.

Explicação (apenas um pouco menos ilegível que o código)

# envolve tudo em um while True: que suprime a mensagem e sai por erro.

JscQ) csaltos input ( Q) no espaço em branco,s junta as partes e salva o resultado J.

^UJ2faz a lista de índices ( U) de Je toma seu 2poder cartesiano ( ^), resultando em todos os pares[h,w] com 0<=h<len(J)e 0<=w<len(J).

+L@+lJ*Fd: para todos ( L) esses pares d, adiciona (+ ) a raiz quadrada ( @… 2) de (a lespessura de Jmais ( +) o produto ( *F) do pard ) ao lado esquerdo do par, criando um trigêmeo [side length, gap height, gap width].

f!|%hT1&eT|t{%R2TgeStThT: ffiltro para trigêmeosT onde

• nem de (!| ):
  • comprimento do lado ( hT) módulo 1 (% … 1) é diferente de zero
  • ambos (& ):
    • altura do vão (eT ) é diferente de zero
    • qualquer um dos (| ):
      • cada número no Rmódulo tripleto ( ) 2 ( %…2 ), com duplicatas ({ ) e a primeira única ( t) removida, não é vazia
      • o maior ( eS) da altura e largura da folga ( tT) é gigual ou igual ao comprimento lateral ( hT)

Sclassifica os trigêmeos lexicograficamente (pelo comprimento lateral e depois pela altura do espaço). oaFtNdepois oordena os trigêmeos peloa diferença bsolute entre a altura da abertura e a largura da abertura ( tN).

Neste ponto, se não tivermos soluções válidas, |avalia seu segundo argumento \n":~(",, que imprime e retorna :~(. hpega a solução ideal (ou ":"se não houver) e é salva em K. Em seguida, hobtém seu comprimento lateral (ou ":"se não houver), slança-o para inteiro (ou falha e fecha se não houver) e é salvo ( =) emQ .

Cada um de ( m) [gap height, gap width]( tK) é então subtraído ( -) do comprimento do lado ( Q) e o resultado dividido por 2 ( /… 2). Os resultados são Aassinados GeH .

Finalmente, entramos em um Wloop hile. Zcomeça em 0 e a cada iteração o incrementamos, mas usamos o valor antigo ( ~hZpense Z++em C).

• Se ( W) o valor antigo estiver em ( {) a rinclinação Gpara (comprimento lateral - G) ( -QG), atribua ( =) ao Jseguinte: cpule Jna posição ( ]) He jpasse nas metades com a largura da folga eKvezes ( *) um espaço ( d). Se o valor não estava no intervalo, basta retornar J. Se esse resultado estiver vazio, pare o loop.
• Remova ( >) os primeiros Qcaracteres Je atribua ( ~) o resultado a J. A partir do valor antigo de J, pegue ( <) os primeiros Qcaracteres e imprima-os.

Finalmente, o #ciclo começa novamente, erros e sai porque cQ)com Qcontendo um número é inválido.

05AB1E , 95 89 bytes

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

Alguns bytes aqui e ali definitivamente podem ser jogados no golfe.

As três primeiras etapas do programa são inspiradas na resposta Stax da @recursive , portanto, faça um !

Experimente online ou verifique todos os casos de teste .

Explicação:

Etapa 1: Remova todos os espaços em branco:

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

Etapa 2: criar todos os trigêmeos possíveis $[a,b,c]$, Onde $a$ é a dimensão da resultante $a×a$ quadrado e $b×c$é o tamanho da lacuna. Fazemos isso criando todos os trigêmeos possíveis usando números inteiros no intervalo$[0,a]$. E então filtramos essas opções onde tudo a seguir é verdadeiro para o trigêmeo:

• $a^2-b×c=L$, Onde $L$ é o comprimento da string
• $(a\gt b)\text{ and }(a\gt c)$
• $(a\pmod2=b\pmod2=c\pmod2)\text{ or }(min(a,b)\neq0)$

Por exemplo: $L=28$resultará nos trigêmeos [[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

Etapa 3: verifique se ainda temos trigêmeos restantes. Caso contrário, saída ":~("; se o fizermos, determine qual usar classificando e deixando apenas o primeiro. Fazemos isso classificando as tuplas$(abs(b-c),b×c)$.

Por exemplo: os trigêmeos [[6,2,4],[6,4,2],[8,6,6]]serão classificados em [[8,6,6],[6,2,4],[6,4,2]], após o qual [8,6,6]restará apenas .

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

Etapa 4: crie uma lista de como devemos dividir a string para inserir os espaços. Isso é feito assim:

Dado $[a,b,c]$, crie uma lista com:

• Como primeiro item: $\frac{a-b}{2}×a + \frac{a-c}{2}$
• Como meio $b-1$ Unid: ${a-c}$
• Como último item: $a^2$

Por exemplo: trigêmeo [7,3,5]resultará na 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`

Etapa 5: e finalmente dividimos a string com base nesta lista, junte-a novamente com $c$ quantidade de espaços, divida-o em partes de tamanho $c$e junte-se a eles por novas linhas. Por exemplo:

Cordas "Alongtesttoseeifitworksasintended."dividido de acordo com a lista [15,2,2,35]resultará em: ["Alongtesttoseei","fi","tw","orksasintended."]. A isso se juntam os$c=5$quantidade de espaços para "Alongtesttoseei fi tw orksasintended.". E depois divida em partes de tamanho$a=7$a isto: ["Alongte","sttosee","i f","i t","w o","rksasin","tended."]. Que é então juntado por novas linhas à saída.

    £              #   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)