Alice là một thực tập sinh trong một công ty sử dụng Brainfuck làm ngôn ngữ chính cho cả phát triển phía máy khách và phía máy chủ. Alice vừa mới viết mã đầu tiên của mình và cô ấy hơi lo lắng khi cô ấy đã sẵn sàng cho lần đánh giá mã đầu tiên của mình.

Alice muốn làm cho mã của mình được định dạng đúng và trông đẹp mắt, nhưng cô ấy không có thời gian để đọc hướng dẫn về kiểu mã công ty gồm 328 trang, vì vậy cô ấy đã quyết định định dạng nó như một hình vuông hoàn hảo . Than ôi, chiều dài mã có thể không đủ để tạo thành một hình vuông, vì vậy cô quyết định để lại một khoảng trống hình chữ nhật ở giữa. Khoảng trống phải được căn giữa hoàn hảo và càng gần hình vuông càng tốt.

Ví dụ

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

Perfect         OK         Acceptable   Unacceptable    No way!        Nope.

Viết một chương trình hoặc một chức năng để giúp Alice. Cho mã của Alice là một chuỗi đầu vào, đầu ra mã được định dạng chính xác như được mô tả dưới đây nếu có thể. Nếu định dạng là không thể, xuất biểu tượng cảm xúc khóc :~(.

Đây là môn đánh gôn để các câu trả lời được tính theo byte với ít byte hơn là mục tiêu.

Những ràng buộc

1. Chương trình hoặc hàm của bạn nên lấy một chuỗi đơn làm đầu vào và đầu ra một hoặc nhiều dòng văn bản (hoặc trả về chuỗi nhiều dòng hoặc mảng chuỗi, nếu bạn triển khai một hàm).
2. Chuỗi đầu vào có thể chứa bất kỳ ký tự ASCII nào kể cả khoảng trắng.
3. Tất cả các khoảng trắng trong đầu vào phải được bỏ qua. Chúng không nên tính chiều dài mã và chúng không nên được sử dụng trong đầu ra.
4. Chuỗi đầu vào chứa ít nhất một ký tự không phải khoảng trắng.
5. Mã được định dạng phải có cùng các ký tự không phải khoảng trắng theo cùng thứ tự như trong mã đầu vào.
6. Mã được định dạng phải là một hình vuông hoàn hảo, tức là tất cả các dòng phải có cùng độ dài và số dòng phải bằng với độ dài của các dòng.
7. Mã được định dạng có thể chứa một khoảng trống ở giữa.
8. Chỉ các ký tự khoảng trắng (mã ASCII 32) có thể được sử dụng trong khoảng trống.
9. Khoảng trống (nếu có) phải là hình chữ nhật.
10. Mỗi dòng mã được định dạng phải chứa ít nhất một ký tự không phải khoảng trắng, nghĩa là chiều rộng khoảng cách phải nhỏ hơn chiều rộng hình vuông (khoảng cách 5x1 không được chấp nhận cho hình vuông 5x5).
11. Khoảng cách nên nằm ngang, tức là chiều rộng khoảng cách nên lớn hơn hoặc bằng chiều cao khoảng cách.
12. Khoảng cách phải được tập trung hoàn hảo.
13. Do đó, khoảng cách giữa chiều rộng và chiều cao phải bằng với độ rộng của hình vuông (ví dụ: khoảng cách hình vuông 5x5 có thể là 1x1, 3x1 hoặc 3x3).
14. Nếu có thể, đầu ra vuông không có khoảng cách nào cả.
15. Trong trường hợp có nhiều giải pháp, hãy chọn một giải pháp có khoảng cách gần nhất với hình vuông, nghĩa là sự khác biệt giữa chiều rộng khoảng cách và chiều cao khoảng cách là tối thiểu (ví dụ: khoảng cách 10x10 thích hợp hơn so với 8x6 và 8x6 thích hợp hơn 6x2).
16. Nếu vẫn có một cà vạt, hãy chọn giải pháp có diện tích khoảng cách tối thiểu (ví dụ: khoảng cách 2x2 được ưu tiên hơn so với 4x4).
17. Nếu không thể định dạng mã ở tất cả, đầu ra :~(.
18. Dòng mới sau dòng cuối cùng là tùy chọn.
19. [Mới] Bạn có thể cho rằng một cách an toàn rằng bất kỳ ký tự nào có mã dưới 33 là khoảng trắng. Tôi hy vọng nó sẽ giúp bạn chơi golf.

Xét nghiệm

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

Trắc nghiệm

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

Tài nguyên

Để tiết kiệm dung lượng, bạn có thể tìm mã mẫu và các trường hợp thử nghiệm bổ sung trên tio.run

[Mới] Bạn có thể xem bảng các giải pháp được chấp nhận cho đầu vào tối đa 100 ký tự . Tôi hoán đổi chiều rộng và chiều cao bởi vì nó có vẻ trực quan hơn.

Lấy cảm hứng từ: Một hình vuông của văn bản

Thay đổi

• Đã thêm 2 bài kiểm tra, sửa lỗi trong mã mẫu.

• Đã thêm bảng giải pháp lên tới 100, thêm vào làm rõ khoảng trắng.

C (gcc) , 354 byte

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

Hãy thử trực tuyến!

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

Đã lưu 4 byte nhờ @Shaggy

Trả về một chuỗi các chuỗi.

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

Hãy thử trực tuyến!

Stax , 80 byte

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

Chạy và gỡ lỗi nó

Làm thế nào nó hoạt động?

• Xem xét tất cả các hình vuông với hình cắt hình chữ nhật.
• Lọc ra các hình dạng chương trình không đúng kích cỡ.
• Lọc ra các hình dạng chương trình không có tính chẵn lẻ phù hợp.
• Lọc ra các hình dạng chương trình trong đó phần cắt ra quá lớn so với hình vuông.
• Nếu không tìm thấy, đầu ra thất bại và thoát.
• Tìm hình dạng giảm thiểu "hình chữ nhật" của cutout, sau đó bằng kích thước cutout.
• Thay thế từng ký tự trong hình dạng chương trình bằng ký tự tương ứng trong đầu vào chương trình.

Giải nén, không được chỉnh sửa và nhận xét nó trông như thế này.

                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

Chạy cái này

Than , 120 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

≔Ｅ⮌⪫⪪Ｓ ωιθ

Tách các khoảng trắng từ đầu vào, sau đó đảo ngược nó và chia nó thành các ký tự, để chúng ta có thể lặp lại các ký tự dễ dàng hơn sau này.

≔⁰η

Bắt đầu với kích thước bằng 0, cho biết không tìm thấy kết quả nào (chưa).

Ｆ⊕Ｌθ

Kiểm tra tất cả các độ dài bên cho đến chiều dài của chuỗi. (Ném một bộ phận vào tất nhiên sẽ làm cho mã nhanh hơn.)

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

Nếu kết quả hóa ra là một hình vuông hoàn hảo thì hãy lưu kích thước hình vuông và cũng đặt đó là kích thước đường viền.

Ｆ⊘ιＦ⊕κ

Lặp lại chiều cao và chiều rộng đường viền có thể (chiều rộng đường viền không lớn hơn chiều cao đường viền, làm cho chiều cao khoảng cách không lớn hơn chiều rộng khoảng cách.)

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

Nếu kích thước của đường viền là độ dài mong muốn và chúng tôi chưa có giải pháp nào hoặc nó không vuông như giải pháp này thì hãy cập nhật giải pháp với kích thước hình vuông và đường viền này.

¿η«

Nếu chúng ta có một giải pháp ...

ＵＯη#

Vẽ một hình chữ nhật của một ký tự tùy ý có kích thước hình vuông đã cho.

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

Nếu đường viền đủ nhỏ để chừa một khoảng trống thì xóa khoảng cách đó. (Lệnh vẽ sẽ vẽ lên trên và sang trái cho các giá trị âm và hoàn toàn không giống các giá trị 0).

ＵＭＫＡ⊟θ

Thay thế tất cả các ký tự (còn lại) bằng các ký tự từ đầu vào.

»:~(

Nếu không thì đầu ra :~(.

Thạch , 91 85 byte

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

Hãy thử trực tuyến!

Một liên kết đơn âm lấy chuỗi đầu vào làm đối số của nó và trả về một chuỗi với đầu ra được định dạng hoặc :~(.

Python 2, 287 281 279 byte

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

Hãy thử trực tuyến!

Sử dụng so sánh danh sách từ điển của Python bằng cách sử dụng cùng các giá trị cho cả việc chọn giải pháp và in nó. Tôi khá chắc chắn 10 4 2 hoặc hơn byte vẫn có thể bị xóa.

Giải trình

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

Xóa các khoảng trắng bằng cách tách với khoảng trắng và nối với "", sau đó chuyển đổi đầu vào thành một danh sách cho sau này. Đồng thời khởi tạo lđộ dài của mã thực tế và pliệt kê các khả năng hợp lệ.

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

Vòng qua tất cả các khả năng của kích thước khoảng cách từ 0*0đến l*l. Tính độ dài cạnh của hình vuông với lký tự mã và x*ykhoảng trắng là s.

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

Kiểm tra xem các điều kiện sau có khớp không:

• s % 1 == 0, tức là một hình vuông hoàn hảo sẽ được hình thành
• x < s-1 > y, tức là xvà ynhiều nhất s-2và vừa vặn bên trong hình vuông
• s % 2 == x % 2 == y % 2, tức là cả hai xvà yphù hợp với tính chẵn lẻ của cạnh và có thể được căn giữa
• nhưng nếu x < 1, tức là x == 0, bỏ qua tất cả nhưng yêu cầu vuông hoàn hảo

Nếu các điều kiện phù hợp, hãy thêm các mục sau vào một tuple pđể tìm mục tối ưu:

• abs(x-y)/2; đầu tiên tìm sự khác biệt tối thiểu xvà yđể có được khoảng cách vuông nhất. Điều này luôn luôn là do đó chúng tôi chia cho 2.
• int(s); tiếp theo tìm chiều dài bên tối thiểu. Vì slà một số nguyên và tăng theo diện tích khoảng cách x*y, nên điều này sắp xếp theo vùng khoảng cách.
• -x; tiếp theo tìm chiều rộng tối đa để thích các khoảng trống ngang. Điều này xuất hiện sau khu vực do cách nó được phát triển, nhưng khu vực này giống nhau x*yvà y*xvì vậy nó hoạt động.

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

Nếu chúng tôi tìm thấy bất kỳ bố cục hợp lệ, hãy tìm một bố cục tối ưu như được mô tả ở trên. Tính đường viền ngang bvà khởi tạo số dòng Ythành 0.

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

Nếu số dòng Ynằm trong khoảng trống (đường viền dọc là b+d, với dtừ bộ dữ liệu), hãy thêm giá trị của khoảng cách chiều rộng của khoảng trống sau đường viền ngang trong c. (Việc sửa đổi clà lý do tại sao chúng ta cần nó là một danh sách.) Sau đó in một dòng của hình vuông và xóa nó khỏi c. Lặp lại snhiều lần, tăng số dòng.

else:print':~('

Nếu không tìm thấy bố cục, thất bại.

Bình thường , 99 98 byte

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

Hãy thử trực tuyến!

Điều này sử dụng thuật toán tương tự như câu trả lời Python của tôi, nhưng nhiều chi tiết được thay đổi đáng kể để ngắn hơn trong Pyth.

Pyth cho thấy tuổi của nó ở đây, vì nó chưa được cập nhật theo độ tuổi và chỉ sử dụng các ký tự ASCII có thể in (đối với mã, không phải dữ liệu), gây lãng phí rất nhiều dung lượng.

Thật thú vị, nếu Pyth sử dụng cùng loại đóng gói cơ sở 256 như Stax, thì chương trình này có thể là 98 log ₂₅₆ 95⌉ = 81 byte, ngay bên cạnh Stax (80 byte) và Jelly (85 byte). Tôi nghĩ điều này cho thấy các ngôn ngữ chơi golf gần gũi như thế nào ngay cả với các mô hình khác nhau mạnh mẽ của chúng.

Giải thích (chỉ hơi khó đọc hơn mã)

#kết thúc mọi thứ trong while True:đó ngăn chặn thông báo và thoát khỏi lỗi.

JscQ) cnhảy đầu vào ( Q) ở khoảng trắng, sgộp các phần lại với nhau và lưu kết quả vào J.

^UJ2làm cho danh sách các chỉ số ( U) của Jvà lấy2 sức mạnh thứ năm ( ^), dẫn đến tất cả các cặp [h,w]với 0<=h<len(J)và 0<=w<len(J).

+L@+lJ*Fd: Cho tất cả ( L) cặp như vậy d, thêm ( +) căn bậc hai ( @... 2) của (các length của Jcộng (+ ) sản phẩm ( *F) của cặp d) sang phía bên trái của cặp, tạo nên một bộ ba [side length, gap height, gap width].

f!|%hT1&eT|t{%R2TgeStThT: f ilter cho bộ ba Ttrong đó

• không phải của ( !|):
  • kích thước chiều dài (hT ) modulo 1 ( %... 1) là khác không
  • cả hai ( &):
    • chiều cao khoảng cách (eT ) là khác không
    • một trong hai| ):
      • mỗi số trong bộ ba ( R) modulo 2 ( %... 2), với bản sao ({ ) và độc đáo đầu tiên ( t) loại bỏ, là không rỗng
      • lớn hơn ( eS) chiều cao khoảng cách và chiều rộng khoảng cách ( tT) là greater-hoặc-bằng so với chiều dài cạnh ( hT)

Ssắp xếp các bộ ba theo từ vựng (theo chiều dài bên, sau đó theo chiều cao khoảng cách). oaFtNsau đó obán các bộ baa chênh lệch bsolute giữa chiều cao khoảng cách và chiều rộng khoảng cách ( tN).

Tại thời điểm này, nếu chúng ta không có giải pháp hợp lệ, hãy |đánh giá đối số thứ hai của nó \n":~(", trong đó in và trả về :~(. hđưa ra giải pháp tối ưu (hoặc ":"nếu không có) và nó được lưu vào K. Sau đó hlấy chiều dài cạnh của nó (hoặc ":"nếu không có), biến snó thành số nguyên (hoặc không thành công và thoát nếu không có) và nó được lưu ( =) vào Q.

Mỗi ( m) [gap height, gap width]( tK) sau đó được trừ ( -) từ chiều dài bên ( Q) và kết quả chia cho 2 ( /... 2). Các kết quả được Agán cho Gvà H.

Cuối cùng, chúng tôi nhập một Wvòng lặp hile. Zbắt đầu từ 0 và mỗi lần lặp chúng ta tăng nó nhưng sử dụng giá trị cũ ( ~hZ, nghĩ Z++theo C).

• Nếu ( W) giá trị cũ nằm trong ( {) range Gto (side length - G) ( -QG), gán ( =) cho Jcác mục sau: chop Jtại vị trí ( ]) Hvà join các nửa với khoảng cách chiều rộng khoảng cách eK( *) một khoảng trắng ( d). Nếu giá trị không nằm trong phạm vi, chỉ cần trả về J. Nếu kết quả này là trống, dừng vòng lặp.
• Xóa ( >) các Qký tự đầu tiên khỏi Jvà gán ( ~) kết quả cho J. Từ giá trị cũ của J, lấy ( <) các Qký tự đầu tiên và in chúng.

Cuối cùng, #vòng lặp bắt đầu lại, lỗi và thoát vì cQ)có Qchứa một số không hợp lệ.

05AB1E , 95 89 byte

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

Một vài byte ở đây và chắc chắn có thể được chơi gôn.

Ba bước đầu tiên của chương trình được lấy cảm hứng từ câu trả lời Stax của @recursive , vì vậy hãy đảm bảo nâng cao anh ấy!

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

Bước 1: Xóa tất cả các khoảng trắng:

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

$[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

":~("$(abs(b-c),b×c)$

Ví dụ: các bộ ba [[6,2,4],[6,4,2],[8,6,6]]sẽ được sắp xếp [[8,6,6],[6,2,4],[6,4,2]], sau đó chỉ [8,6,6]còn lại.

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

Bước 4: Tạo một danh sách về cách chúng ta nên chia chuỗi để chèn khoảng trắng. Điều này được thực hiện như thế này:

$[a,b,c]$

• $\frac{a-b}{2}×a + \frac{a-c}{2}$
• $b-1$${a-c}$
• $a^2$

Ví dụ: bộ ba [7,3,5]sẽ dẫn đến danh sách [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`

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