Алиса - стажер в компании, которая использует Brainfuck в качестве основного языка как для разработки на стороне клиента, так и на стороне сервера. Алиса только что написала свой первый код, и она немного нервничает, готовясь к своему первому обзору кода.

Алиса хочет, чтобы ее код был правильно отформатирован и выглядел красиво, но у нее нет времени, чтобы прочитать руководство по стилю кода компании на 328 страниц, поэтому она решила отформатировать его как идеальный квадрат . Увы, длины кода может быть недостаточно для формирования квадрата, поэтому она решила оставить прямоугольный пробел в середине. Разрывы должны быть идеально отцентрированы и как можно ближе к квадрату .

Примеры

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

Perfect         OK         Acceptable   Unacceptable    No way!        Nope.

Напишите программу или функцию, чтобы помочь Алисе. Учитывая код Алисы в качестве входной строки, выведите правильно отформатированный код, как описано ниже, если это возможно. Если форматирование невозможно, выведите плачущие смайлики :~(.

Это код-гольф, поэтому ответы оцениваются в байтах, а целью является меньшее количество байтов.

Ограничения

1. Ваша программа или функция должна принимать одну строку в качестве входных данных и выводить одну или несколько строк текста (или возвращать многострочную строку или массив строк, если вы реализуете функцию).
2. Входная строка может содержать любые символы ASCII, включая пробелы.
3. Все пробелы во входных данных должны игнорироваться. Они не должны учитывать длину кода и не должны использоваться в выводе.
4. Входная строка содержит хотя бы один непробельный символ.
5. Отформатированный код должен иметь те же непробельные символы в том же порядке, что и во входном коде.
6. Форматированный код должен быть идеальным квадратом, то есть все строки должны иметь одинаковую длину, а количество строк должно быть равно длине строк.
7. Отформатированный код может содержать пробел в середине.
8. В пробеле можно использовать только пробелы (код ASCII 32).
9. Разрыв (если имеется) должен быть прямоугольным.
10. Каждая строка отформатированного кода должна содержать хотя бы один непробельный символ, т.е. ширина зазора должна быть строго меньше ширины квадрата (зазор 5x1 недопустим для квадрата 5x5).
11. Зазор должен быть горизонтальным, то есть ширина зазора должна быть больше или равна высоте зазора.
12. Разрыв должен быть идеально отцентрирован.
13. Следовательно, четность ширины и высоты зазора должна быть такой же, как четность ширины квадрата (например, для зазора 5x5 может быть 1x1, 3x1 или 3x3).
14. Если возможно, выведите квадрат без зазора.
15. В случае нескольких решений выберите одно с зазором, ближайшим к квадрату, т. Е. Разница между шириной и высотой зазора минимальна (например: зазор 10x10 предпочтительнее, чем 8x6, и 8x6 предпочтительнее, чем 6x2).
16. Если все еще есть связь, выберите решение с минимальной площадью зазора (например, зазор 2x2 предпочтительнее, чем 4x4).
17. Если вообще невозможно отформатировать код, выведите :~(.
18. Новая строка после последней строки необязательна.
19. [Новое] Вы можете смело предположить, что любой символ с кодом ниже 33 является пробелом. Я надеюсь, что это поможет вам для игры в гольф.

тесты

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

Хитрые тесты

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

Ресурсы

Для экономии места вы можете найти образец кода и дополнительные тестовые примеры на tio.run

[Новое] Вы можете взглянуть на таблицу принятых решений для ввода длиной до 100 символов . Я поменял местами ширину и высоту, потому что это выглядит более интуитивно.

Вдохновлен: квадрат текста

изменения

• Добавлено 2 теста, исправлена ​​ошибка в примере кода.

• Добавлена ​​таблица решений до 100, добавлено уточнение пробелов.

C (gcc) , 354 байта

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

Попробуйте онлайн!

JavaScript (ES6),  284 ... 274  270 байт

Сохранено 4 байта благодаря @Shaggy

Возвращает массив строк.

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

Попробуйте онлайн!

Stax , 80 байт

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

Запустите и отладьте его

Как это работает?

• Рассмотрим все квадраты с прямоугольными вырезами.
• Отфильтруйте формы программ, которые имеют неправильный размер.
• Отфильтруйте формы программ, которые не имеют соответствия четности.
• Отфильтруйте формы программы, где вырез слишком велик для квадрата.
• Если ничего не найдено, выходной сбой и выход.
• Найдите форму, которая минимизирует «прямоугольность» выреза, затем по размеру выреза.
• Замените каждый символ в форме программы соответствующим символом на входе программы.

Распаковано, разглажено и прокомментировано это выглядит так.

                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

Запустите этот

Древесный уголь , 120 байт

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

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение:

≔Ｅ⮌⪫⪪Ｓ ωιθ

Удалите пробелы из входных данных, затем переверните их и разделите на символы, чтобы позже мы могли более легко зацикливать символы.

≔⁰η

Начните с размера ноль, указывая, что результат не найден (пока).

Ｆ⊕Ｌθ

Проверьте все длины сторон до длины строки. (Добавление деления, конечно, сделает код быстрее.)

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

Если в результате получится идеальный квадрат, сохраните размер квадрата и установите его в качестве размера границы.

Ｆ⊘ιＦ⊕κ

Обведите все возможные значения высоты и ширины границы (ширина границы не превышает высоту границы, поэтому высота зазора не превышает ширину зазора).

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

Если размер границы - желаемая длина, и у нас пока нет решения, или оно не такое квадратное, как это решение, то обновите решение с помощью этого квадрата и размеров границы.

¿η«

Если у нас есть решение ...

ＵＯη#

Нарисуйте прямоугольник произвольного символа с заданным размером квадрата.

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

Если граница достаточно мала, чтобы оставить зазор, стереть зазор. (Команда рисования будет рисовать вверх и влево для отрицательных значений и вообще не любит нулевые значения.)

ＵＭＫＡ⊟θ

Замените все (оставшиеся) символы на символы из ввода.

»:~(

В противном случае вывод :~(.

Желе , 91 85 байт

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

Попробуйте онлайн!

Монадическая ссылка, которая принимает входную строку в качестве аргумента и возвращает строку либо с форматированным выводом, либо :~(.

Python 2, 287 281 279 байт

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

Попробуйте онлайн!

Использует сравнение лексикографического списка Python, используя одинаковые значения как для выбора решения, так и для его печати. Я уверен, что 10 4 2 или около того байта все еще можно сбрить.

объяснение

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

Удалите пробелы, разделив их пробелами и присоединившись к ним "", а затем преобразуйте входные данные в список для дальнейшего использования. Также инициализируйте lдля длины фактического кода и pдля списка допустимых возможностей.

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

Переберите все возможности размеров зазора от 0*0до l*l. Вычислить длину ребра квадрата с помощью lсимволов кода и x*yпробелов как s.

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

Проверьте, соответствуют ли следующие условия:

• s % 1 == 0т.е. будет сформирован идеальный квадрат
• x < s-1 > yто есть xи yнаходятся не более s-2и вписываются в квадрат
• s % 2 == x % 2 == y % 2т. е. оба xи yсоответствуют четности края и могут быть центрированы
• но если x < 1, т.е. x == 0игнорировать все, кроме требования идеального квадрата

Если условия совпадают, добавьте следующие элементы в кортеж, pчтобы найти оптимальный:

• abs(x-y)/2; сначала найдите минимальную разницу xиy получите самый квадратный разрыв. Это всегда даже так, мы делим на 2.
• int(s); затем найдите минимальную длину стороны. Так sкак является целым числом и увеличивается как область разрыва x*y, это сортирует по области разрыва.
• -x; Затем найдите максимальную ширину, чтобы предпочесть горизонтальные промежутки. Это происходит после области из-за того, как она была разработана, но область такая же, x*yи y*xпоэтому она работает.

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

Если мы нашли какие-либо допустимые макеты, найдите оптимальный, как описано выше. Вычислите горизонтальную границу bи инициализируйте номер строки Yв 0.

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

Если номер строки Yнаходится внутри пробела (вертикальная граница - b+dс dкортежем), добавьте значение ширины пробела после горизонтальной границы в c. (Модификация c- это то, почему нам нужно, чтобы это был список.) Затем выведите линию квадрата и удалите ее из c. Повторите sвремя, увеличивая номер строки.

else:print':~('

Если макеты не найдены, произойдет сбой.

Pyth , 99 98 байтов

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

Попробуйте онлайн!

При этом используется тот же алгоритм, что и в моем ответе на Python, но многие детали значительно изменены, чтобы быть короче в Pyth.

Здесь Pyth показывает свой возраст, поскольку он не обновлялся годами и использует только печатаемые символы ASCII (для кода, а не для данных), тратя много места.

Интересно, что если бы Pyth использовал тот же тип упаковки 256, что и Stax, эта программа могла бы иметь размер log98 log ₂₅₆ 95 81 = 81 байт, в непосредственной близости от Stax (80 байт) и Jelly (85 байт). Я думаю, что это хорошо показывает, насколько близки языки игры в гольф даже с их совершенно разными парадигмами.

Объяснение (только немного менее нечитаемо, чем код)

#оборачивает все в, while True:что подавляет сообщение и выходит из-за ошибки.

JscQ) cвход хмеля (Qsвыполняет прыжок ) в пустом месте, объединяет части и сохраняет результат в J.

^UJ2составляет список индексов ( U) Jи принимает его 2декартову степень (^ ), в результате чего все пары [h,w]с 0<=h<len(J)и 0<=w<len(J).

+L@+lJ*Fd: для всех ( L) таких пар dдобавляет ( +) квадратный корень ( @… 2) из ( lдлина Jплюс ( +) продукта (*F ) пары d) к левой стороне пары, создавая триплет [side length, gap height, gap width].

f!|%hT1&eT|t{%R2TgeStThT: f ilter для тройни Tгде

• ни один из ( !|):
  • длина стороны (hT ) по модулю 1 ( %… 1) не равна нулю
  • оба из ( &):
    • высота зазора (eT ) не равна нулю
    • любой из (| ):
      • каждое число в триплете ( R) по модулю 2 ( %… 2) с дубликатами ({t удаленными ) и первым уникальным ( ) непусто
      • большее ( eS) высоты зазора и ширины зазора ( tT) больше gили равно длине стороны ( hT)

Sсортирует триплеты лексикографически (по длине стороны, затем по высоте зазора). oaFtNзатем oвычисляет тройки по aабсолютной разнице между высотой зазора и шириной зазора ( tN).

В этот момент, если у нас нет действительных решений, |оценивается его второй аргумент \n":~(", который печатает и возвращает :~(. hпринимает оптимальное решение (или, ":"если его нет), и оно сохраняется в K. Затем hпринимает длину стороны (или, ":"если ее нет), sпреобразует ее в целое число (или терпит неудачу и завершает работу, если ее нет), и она сохраняется (= ) вQ .

Затем каждое из ( m) [gap height, gap width]( tK) вычитается ( -) из длины стороны ( Q), а результат делится на 2 ( /… 2). Результаты Aподписаны на Gи H.

Наконец, мы входим в Wпетлю. Zначинается с 0 и каждую итерацию мы увеличиваем, но используем старое значение ( ~hZподумайте Z++на С).

• Если ( W) старое значение находится в ( {) range Gto (side length - G) ( -QG), присвойте ( =) Jследующее: cпереходите Jв position ( ]) Hи jразбейте половинки с шириной промежутка eKtimes ( *) a space ( d). Если значение не было в диапазоне, просто верните J. Если этот результат пуст, остановите цикл.
• Удалите ( >) первые Qсимволы из Jи назначьте ( ~) результат J. Из старого значения Jвозьмите ( <) первые Qсимволы и напечатайте их.

Наконец, #цикл начинается снова, ошибки и выход, потому что cQ)с Qсодержащим число недопустимо.

05AB1E , 95 89 байт

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

Несколько байтов здесь и там определенно можно сыграть в гольф.

Первые три шага программы навеяны ответом Stax от @recursive , так что постарайтесь поддержать его!

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

Шаг 1: Удалите все пробелы:

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

Шаг 2: Создайте все возможные триплеты $[a,b,c]$, где $a$ это размер результирующего $a×a$ квадрат и $b×c$это размер разрыва. Мы делаем это, создавая все возможные триплеты, используя целые числа в диапазоне$[0,a]$, И затем мы фильтруем их, где все следующее верно для триплета:

• $a^2-b×c=L$, где $L$ длина строки
• $(a\gt b)\text{ and }(a\gt c)$
• $(a\pmod2=b\pmod2=c\pmod2)\text{ or }(min(a,b)\neq0)$

Например: $L=28$приведет к тройняшкам [[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

Шаг 3: Проверьте, остались ли еще триплеты. Если нет, вывод ":~("; если мы это сделаем, определите, какой использовать, сортируя и оставляя только первое. Мы делаем это путем сортировки кортежей$(abs(b-c),b×c)$,

Например: тройки [[6,2,4],[6,4,2],[8,6,6]]будут отсортированы [[8,6,6],[6,2,4],[6,4,2]], после чего останутся только [8,6,6].

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

Шаг 4: Создайте список того, как мы должны разделить строку, чтобы вставить пробелы. Это делается так:

Данный $[a,b,c]$создайте список с помощью:

• Как первый пункт: $\frac{a-b}{2}×a + \frac{a-c}{2}$
• Как середина $b-1$ Предметы: ${a-c}$
• Как последний пункт: $a^2$

Например: триплет [7,3,5]приведет к появлению списка [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`

Шаг 5: И, наконец, мы разбиваем строку на основе этого списка, соединяем его вместе с $c$ количество пробелов, разбить его на части размера $c$и присоединяйся к ним вместе с помощью новых строк. Например:

Строка "Alongtesttoseeifitworksasintended."разделена в соответствии со списком [15,2,2,35]приведет к: ["Alongtesttoseei","fi","tw","orksasintended."]. Затем к нему присоединяются$c=5$количество мест до "Alongtesttoseei fi tw orksasintended.". А затем разделить на части размера$a=7$к этому: ["Alongte","sttosee","i f","i t","w o","rksasin","tended."]. К которому затем добавляются новые строки для вывода.

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