Alice, Brainfuck'ı hem istemci tarafı hem de sunucu tarafı geliştirme için birincil dil olarak kullanan bir şirkette stajyer. Alice sadece ilk kodunu yazdı ve ilk kod incelemesine hazırlanırken biraz gergin.

Alice kodunu düzgün bir şekilde biçimlendirmek ve güzel görünmek istiyor, ancak 328 sayfalık şirket kodu stil kılavuzunu okumak için zamanı yok, bu yüzden mükemmel bir kare olarak biçimlendirmeye karar verdi . Ne yazık ki, kod uzunluğu bir kare oluşturmak için yetersiz olabilir, bu yüzden ortada dikdörtgen bir boşluk bırakmaya karar verdi . Boşluklar mükemmel bir şekilde ortalanmış ve mümkün olduğunca kareye yakın olmalıdır .

Örnekler

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

Perfect         OK         Acceptable   Unacceptable    No way!        Nope.

Alice'e yardım etmek için bir program veya işlev yazın. Alice'in kodu giriş dizesi olarak verildiğinde, mümkünse aşağıda açıklandığı gibi düzgün biçimlendirilmiş kod alın. Biçimlendirme mümkün değilse, ağlayan emoji çıktısı alın :~(.

Bu kod golf, bu yüzden cevaplar bayt olarak puanlanır, amaç daha az bayttır.

Kısıtlamalar

1. Programınız veya işleviniz giriş olarak tek bir dize almalı ve bir veya daha fazla metin satırı vermelidir (veya bir işlev uygularsanız çok satırlı dize veya dize dizisi döndürür).
2. Giriş dizesi, boşluklar dahil olmak üzere herhangi bir ASCII karakteri içerebilir.
3. Girişteki tüm boşluklar göz ardı edilmelidir. Kod uzunluğu için sayılmamalı ve çıktıda kullanılmamalıdır.
4. Giriş dizesi en az bir boşluk olmayan karakter içeriyor.
5. Biçimlendirilmiş kod, giriş kodundakiyle aynı sırada boşluk olmayan karakterlerle aynı olmalıdır.
6. Biçimlendirilmiş kod mükemmel bir kare olmalıdır, yani tüm satırlar aynı uzunlukta olmalı ve satır sayısı satırın uzunluğuna eşit olmalıdır.
7. Biçimlendirilmiş kod ortasında bir boşluk olabilir.
8. Boşlukta yalnızca boşluk karakterleri (ASCII kodu 32) kullanılabilir.
9. Boşluk (varsa) dikdörtgen olmalıdır.
10. Biçimlendirilmiş her kod satırı en az bir boşluk olmayan karakter içermelidir, yani boşluk genişliği kesinlikle kare genişliğinden daha az olmalıdır (5x5 boşluğu için 5x1 boşluğu kabul edilemez).
11. Boşluk yatay olmalıdır, yani boşluk genişliği boşluk yüksekliğinden büyük veya ona eşit olmalıdır.
12. Boşluk mükemmel bir şekilde ortalanmalıdır.
13. Sonuç olarak boşluk genişliği ve yükseklik paritesi kare genişliği paritesi ile aynı olmalıdır (örneğin 5x5 kare boşluk için 1x1, 3x1 veya 3x3 olabilir).
14. Mümkünse, hiçbir boşluk olmadan kare çıktı.
15. Birden fazla çözüm olması durumunda, kareye en yakın boşluğa sahip bir tane seçin, yani boşluk genişliği ve boşluk yüksekliği arasındaki fark minimumdur (örneğin: boşluk 10x10, 8x6'dan daha tercih edilir ve 8x6, 6x2'den daha tercih edilir).
16. Hala bir kravat varsa, minimum boşluk alanına sahip çözümü seçin (örneğin boşluk 2x2, 4x4'ten daha fazla tercih edilir).
17. Kodu biçimlendirmek mümkün değilse çıktı alın :~(.
18. Son satırdan sonraki satırsonu isteğe bağlıdır.
19. [Yeni] 33'ün altında kodu olan herhangi bir karakterin bir boşluk olduğunu güvenle varsayabilirsiniz. Umarım golf için sana yardımcı olur.

Testler

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

Zor testler

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

kaynaklar

Yerden tasarruf etmek için tio.run'da örnek kod ve ekstra test örnekleri bulabilirsiniz

[Yeni] 100 karaktere kadar girişler için kabul edilen çözümler tablosuna bakabilirsiniz . Genişliği ve yüksekliği değiştirdim çünkü daha sezgisel görünüyor.

İlham kaynağı: Bir kare metin

değişiklikler

• 2 test eklendi, örnek kodda hata düzeltildi.

• 100'e kadar çözüm tablosu eklendi, beyaz alan açıklaması eklendi.

C (gcc) , 354 bayt

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

Çevrimiçi deneyin!

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

@Shaggy sayesinde 4 bayt kaydedildi

Bir dizgi dizisi döndürür.

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

Çevrimiçi deneyin!

Stax , 80 bayt

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

Çalıştır ve hata ayıkla

O nasıl çalışır?

• Dikdörtgen kesikli tüm kareleri düşünün.
• Doğru boyutta olmayan program şekillerini filtreleyin.
• Eşleşen paritesi olmayan program şekillerini filtreleyin.
• Kesmenin kare için çok büyük olduğu program şekillerini filtreleyin.
• Hiçbiri bulunmazsa, çıkış hatası ve çıkış.
• Kesimin "dikdörtgen şeklini" en aza indiren şekli, sonra kesim boyutuna göre bulun.
• Program şeklindeki her karakteri, program girişindeki karşılık gelen karakterle değiştirin.

Ambalajından çıkarılmış, çözülmemiş ve yorum yapılmış gibi görünüyor.

                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

Bunu çalıştır

Kömür , 120 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

≔Ｅ⮌⪫⪪Ｓ ωιθ

Girişteki boşlukları soyun, sonra ters çevirin ve karakterlere bölün, böylece daha sonra karakterler üzerinde daha kolay döngü oluşturabiliriz.

≔⁰η

Sıfır boyutuyla başlayın, sonuç bulunamadı (henüz).

Ｆ⊕Ｌθ

Dize uzunluğuna kadar olan tüm yan uzunlukları kontrol edin. (Bir bölümü atmak elbette kodu daha hızlı hale getirir.)

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

Sonuç mükemmel bir kare olursa, kare boyutunu kaydedin ve bunu kenarlık boyutu olarak ayarlayın.

Ｆ⊘ιＦ⊕κ

Olası sınır yüksekliklerinin ve genişliklerinin üzerinde döngü yapın (kenarlık genişliği kenarlık yüksekliğinden daha büyük değildir, bu da boşluk yüksekliğini boşluk genişliğinden fazla yapmaz.)

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

Kenarlığın boyutu istenen uzunluktaysa ve henüz bir çözümümüz yoksa veya bu çözüm kadar kare değilse, çözümü bu kare ve kenarlık boyutlarıyla güncelleyin.

¿η«

Bir çözümümüz varsa ...

ＵＯη#

Verilen kare boyutunda rastgele bir karakterin dikdörtgenini çizin.

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

Kenarlık bir boşluk bırakacak kadar küçükse, boşluğu silin. (Çizim komutu negatif değerler için yukarı ve sol çizer ve sıfır değerlerinden hiç hoşlanmaz.)

ＵＭＫＡ⊟θ

Tüm (kalan) karakterleri girişteki karakterlerle değiştirin.

»:~(

Aksi takdirde çıktı :~(.

Jöle , 91 85 bayt

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

Çevrimiçi deneyin!

Girdi dizesini bağımsız değişkeni olarak alan ve biçimlendirilmiş çıktıya sahip bir dize veya döndüren monadik bir bağlantı :~(.

Python 2, 287 281 279 bayt

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

Çevrimiçi deneyin!

Hem bir çözüm seçmek hem de yazdırmak için aynı değerleri kullanarak Python'un sözlük listesi karşılaştırmasını kullanır. Eminim 10 4 2 kadar bayt hala tıraş edilebilir.

açıklama

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

Beyaz boşlukla bölerek ile birleşerek beyaz boşlukları kaldırın "", sonra girdiyi daha sonra kullanmak üzere bir listeye dönüştürün. Ayrıca l, gerçek kodun uzunluğuna ve pgeçerli olasılıkların listesine başlayın.

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

Dan boşluk boyutları her olasılıkları döngü 0*0için l*l. Karenin kenar uzunluğunu lkod karakterleri ve x*yboşluklarla hesaplayın s.

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

Aşağıdaki koşulların eşleşip eşleşmediğini kontrol edin:

• s % 1 == 0yani mükemmel bir kare oluşturulacak
• x < s-1 > y, yani xve yen fazlas-2 ve meydanda içine sığacak
• s % 2 == x % 2 == y % 2, yani her ikisi xve ykenarın paritesiyle eşleşir ve ortalanabilir
• ancak x < 1, yani x == 0, mükemmel kare gereksinimi hariç hepsini yoksay

Koşullar eşleşirse, pen uygun olanı bulmak için aşağıdaki öğeleri bir demet halinde ekleyin :

• abs(x-y)/2; İlk minimal bir fark bulmak xve yen kare boşluğu alır. Bu her zaman bile 2'ye böleriz.
• int(s); daha sonra minimum yan uzunluğu bulun. Bu yana sbir tamsayıdır ve boşluk alanı olarak artar x*y, boşluk alanına göre bu tür.
• -x; daha sonra yatay boşlukları tercih etmek için maksimum genişliği bulun. Bu, alanın nasıl geliştirildiğinden sonra gelir, ancak alan aynıdır x*yve y*xbu nedenle çalışır.

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

Geçerli bir düzen bulursak, yukarıda açıklandığı gibi en uygun düzeni bulun. Yatay kenarlığı hesaplayın bve satır numarasını Y0 olarak başlatın.

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

Satır numarası Eğer Yboşluk içindedir (dikey sınırıdır b+dile,d başlığın dan), yatay sınır sonra boşlukların boşluk genişliği yetmeyecek ekleyin c. (Modifikasyonunun cneden bir liste olması gerektiğidir.) Sonra karenin bir çizgisini yazdırın ve listeden kaldırın c. sSatır numarasını artırarak süreleri tekrarlayın .

else:print':~('

Herhangi bir düzen bulunmadıysa başarısız olun.

Pyth , 99 98 bayt

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

Çevrimiçi deneyin!

Bu, Python cevabımla aynı algoritmayı kullanıyor, ancak birçok ayrıntı Pyth'te daha kısa olacak şekilde önemli ölçüde değiştirildi.

Pyth yaşını burada gösterir, çünkü çağlarda güncellenmemiştir ve sadece yazdırılabilir ASCII karakterlerini (kod için, veri için değil) kullandığı için çok fazla alan harcar.

İlginç bir şekilde, Pyth Stax ile aynı türde bir taban 256 ambalaj kullandıysa, bu program ⌈98 günlük _{256 olabilir} Stax (80 bayt) ve Jelly (85 bayt) hemen yanında 95⌉ = 81 bayt uzunluğunda olabilir. Bence bu, golf dillerinin çok farklı paradigmalarıyla bile ne kadar yakın olduğunu gösteriyor.

Açıklama (koddan biraz daha az okunamıyor)

#while True:iletiyi bastıran ve hatadan çıkılan her şeyi sarar .

JscQ) cQwhitespace ( ) sişaretini boşlukta atlar , parçaları birleştirir ve sonucu kaydeder J.

^UJ2Kartezyen gücünü ( U) endekslerinin ( ) listesini yapar Jve alır2^ tüm çiftleri ile sonuçlanan) [h,w]ile 0<=h<len(J)ve 0<=w<len(J).

+L@+lJ*Fd: Tüm (için L) bu tür çiftleri d, (ekler +) karekökünü ( @... 2Olarak) ( liçinde ength Jartı ( +) ürün (*F çifti) dbir üçlü oluşturma, bir çiftin sol tarafına) [side length, gap height, gap width].

f!|%hT1&eT|t{%R2TgeStThT: f Üçüz için ilter Tnerede

• hiçbiri (!| ):
  • yan uzunluk ( hT) modulo 1 (% …1 ) sıfırdan farklı
  • her ikiside (& ):
    • boşluk yüksekliği (eT ) sıfırdan farklı
    • Bir digeri (| ):
      • üçlü ( R) modulo 2'deki ( %… 2) her sayı , kopyalarla ({ ) ve ilk benzersiz (t ) kaldırılan boş bırakılır
      • eSboşluk yüksekliği ve boşluk genişliği ( tT) daha büyük ( ), gyan uzunluktan ( hT) reater veya eşittir ( )

Süçüzleri sözlükbilimsel olarak sıralar (yan uzunluğa, sonra boşluk yüksekliğine göre). oaFtNdaha sonra oüçüzleri aboşluk yüksekliği ve boşluk genişliği (tN ) .

Bu noktada, geçerli bir çözümümüz yoksa , baskı ve geri dönen |ikinci argümanını değerlendirir . optimal çözümü alır (veya yoksa) ve kaydedilir . Daha sonra yan uzunluğunu alır (veya hiçbiri değilse), tamsayıya çevirir (veya hiçbiri yoksa başarısız olur ve çıkar) ve kaydedilir ( ) .\n":~(":~(h":"Kh":"s=Q

( m) [gap height, gap width]( tK) Öğelerinin her biri daha sonra -kenar uzunluğundan ( Q) çıkarılır ( ) ve sonucun 2'ye ( /… 2) bölünmesiyle elde edilir . Sonuçlar edilmektedir Aiçin ssigned Gve H.

Son olarak, bir While döngüsüne giriyoruz . Z0'da başlar ve her yinelemede onu artırırız, ancak eski değeri kullanırız ( C'yi ~hZdüşünün Z++).

• (Eğer W) eski değer (içinde {) range G(kenar uzunluğu - için G) ( -QG), atama ( =kadar) Jaşağıda: catlama Jpozisyonunda ( ]) Hve jgenişlik boşluğu ile yarım Oin eKkez ( *) bir boşluk ( d). Değer aralıkta değilse, geri dönün J. Bu sonuç boşsa, döngüyü durdurun.
• >İlk Qkarakterleri kaldırın ( ) ve sonuca J( ~) atayın J. Eski değerinden , ilk karakterleri J( <) alıp Qyazdırın.

Son olarak, #döngü yeniden başlar, çünkü hatalar ve sonlandırılıyor cQ)ile Qbir sayı içeren geçersiz.

05AB1E , 95 89 bayt

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

Burada birkaç bayt var ve kesinlikle golf edilebilir.

Programın ilk üç adımı @recursive'ın Stax cevabından esinlenilmiştir , bu yüzden onu onayladığınızdan emin olun!

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Açıklama:

Adım 1: Tüm beyaz boşlukları kaldırın:

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

2. Adım: Tüm olası üçüzleri oluşturun $[a,b,c]$, nerede $a$ ortaya çıkan boyut $a×a$ kare ve $b×c$boşluğun boyutudur. Bunu, aralıktaki tamsayıları kullanarak tüm olası üçüzleri oluşturarak yaparız$[0,a]$. Ve sonra bunları üçlünün aşağıdakileri doğru olduğunda filtreliyoruz:

• $a^2-b×c=L$, nerede $L$ ipin uzunluğu
• $(a\gt b)\text{ and }(a\gt c)$
• $(a\pmod2=b\pmod2=c\pmod2)\text{ or }(min(a,b)\neq0)$

Örneğin: $L=28$üçlülere neden olur [[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

Adım 3: Hala üçüz kaldığımızdan emin olun. Değilse, çıktı ":~("; yaparsak, hangisini kullanacağını sıralayarak ve sadece ilkini bırakarak belirleyin. Bunu tupleleri sıralayarak yapıyoruz$(abs(b-c),b×c)$.

Örneğin: üçüzler [[6,2,4],[6,4,2],[8,6,6]]sıralanacaktır [[8,6,6],[6,2,4],[6,4,2]], daha sonra sadece [8,6,6]kalacaktır.

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

Adım 4: Boşluk eklemek için dizeyi nasıl bölmemiz gerektiğine dair bir liste oluşturun. Bu şu şekilde yapılır:

verilmiş $[a,b,c]$, aşağıdakileri içeren bir liste oluşturun:

• İlk öğe olarak: $\frac{a-b}{2}×a + \frac{a-c}{2}$
• Orta olarak $b-1$ öğe: ${a-c}$
• Son öğe olarak: $a^2$

Örneğin: üçlü [7,3,5]liste ile sonuçlanır [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`

Adım 5: Sonunda dizeyi bu listeye göre ayırıyoruz, $c$ boşluk, boyut bölümlerine ayırın $c$ve yeni satırlarla bunlara katılın. Örneğin:

"Alongtesttoseeifitworksasintended."Listeye göre dizenin bölünmesi [15,2,2,35]: ile sonuçlanır ["Alongtesttoseei","fi","tw","orksasintended."]. Buna daha sonra$c=5$boşluk sayısı "Alongtesttoseei fi tw orksasintended.". Ve sonra boyut bölümlerine ayrıldı$a=7$Buna: ["Alongte","sttosee","i f","i t","w o","rksasin","tended."]. Bu daha sonra çıktı için yeni satırlarla birleştirilir.

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