Alice adalah pekerja magang di perusahaan yang menggunakan Brainfuck sebagai bahasa utama untuk pengembangan sisi klien dan server. Alice baru saja menulis kode pertamanya dan dia sedikit gugup saat dia bersiap-siap untuk tinjauan kode pertamanya.

Alice ingin membuat kodenya diformat dengan benar dan terlihat bagus, tetapi dia tidak punya waktu untuk membaca panduan gaya kode perusahaan setebal 328 halaman, jadi dia memutuskan untuk memformatnya sebagai kotak yang sempurna . Sayangnya, panjang kode mungkin tidak cukup untuk membentuk persegi, jadi dia memutuskan untuk meninggalkan celah persegi di tengah. Kesenjangan harus dipusatkan dengan sempurna dan sedekat mungkin dengan kotak .

Contohnya

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

Perfect         OK         Acceptable   Unacceptable    No way!        Nope.

Tulis program atau fungsi untuk membantu Alice. Diberikan kode Alice sebagai string input, output kode diformat dengan benar seperti yang dijelaskan di bawah jika memungkinkan. Jika memformat tidak mungkin, keluarkan emoji menangis :~(.

Ini adalah kode-golf sehingga jawaban diberi skor dalam byte dengan tujuan lebih sedikit.

Kendala

1. Program atau fungsi Anda harus mengambil string tunggal sebagai input dan output satu atau lebih baris teks (atau mengembalikan string multi-baris atau array string, jika Anda mengimplementasikan suatu fungsi).
2. String input dapat berisi karakter ASCII termasuk spasi putih.
3. Semua spasi putih dalam input harus diabaikan. Mereka tidak harus menghitung panjang kode dan mereka tidak boleh digunakan dalam output.
4. String input berisi setidaknya satu karakter non-spasi putih.
5. Kode yang diformat harus memiliki karakter bukan spasi yang sama dalam urutan yang sama seperti dalam kode input.
6. Kode yang diformat harus berupa kuadrat sempurna, yaitu semua garis harus memiliki panjang yang sama, dan jumlah garis harus sama dengan panjang garis.
7. Kode yang diformat mungkin mengandung celah di tengah.
8. Hanya karakter spasi (kode ASCII 32) yang dapat digunakan dalam jeda.
9. Celah (jika ada) harus persegi panjang.
10. Setiap baris kode yang diformat harus mengandung setidaknya satu karakter non-spasi, yaitu lebar celah harus benar-benar kurang dari lebar kuadrat (celah 5x1 tidak dapat diterima untuk 5x5 kuadrat).
11. Celah harus horisontal, yaitu lebar celah harus lebih besar atau sama dengan tinggi celah.
12. Celah harus terpusat sempurna.
13. Konsekuensinya, lebar celah dan paritas tinggi harus sama dengan paritas lebar persegi (misalnya untuk 5x5, celah persegi bisa 1x1, 3x1, atau 3x3).
14. Jika memungkinkan, kuadrat keluaran tanpa celah sama sekali.
15. Dalam hal beberapa solusi, pilih satu dengan gap yang paling dekat dengan kuadrat, yaitu perbedaan antara lebar celah dan tinggi celah minimal (misalnya: gap 10x10 lebih disukai daripada 8x6, dan 8x6 lebih disukai daripada 6x2).
16. Jika masih ada seri, pilih solusi dengan area gap minimal (misalnya gap 2x2 lebih disukai daripada 4x4).
17. Jika tidak mungkin memformat kode sama sekali, output :~(.
18. Baris baru setelah baris terakhir adalah opsional.
19. [Baru] Anda dapat dengan aman berasumsi bahwa karakter apa pun dengan kode di bawah 33 adalah spasi. Saya harap ini akan membantu Anda untuk bermain golf.

Tes

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

Tes rumit

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

Sumber daya

Untuk menghemat ruang, Anda dapat menemukan kode sampel dan kasus uji tambahan di tio.run

[Baru] Anda dapat melihat tabel solusi yang diterima untuk input hingga 100 karakter . Saya menukar lebar dan tinggi karena sepertinya terlihat lebih intuitif.

Terinspirasi oleh: Seperempat teks

Perubahan

• Menambahkan 2 tes, memperbaiki bug dalam kode sampel.

• Menambahkan tabel solusi hingga 100, menambahkan klarifikasi ruang-putih.

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

Cobalah online!

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

Disimpan 4 byte berkat @Shaggy

Mengembalikan array string.

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

Cobalah online!

Stax , 80 byte

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

Jalankan dan debug itu

Bagaimana cara kerjanya?

• Pertimbangkan semua kotak dengan guntingan persegi panjang.
• Memfilter bentuk program yang bukan ukuran yang tepat.
• Memfilter bentuk program yang tidak memiliki kesamaan paritas.
• Saring bentuk program di mana potongan terlalu besar untuk kotak.
• Jika tidak ada yang ditemukan, output gagal dan berhenti.
• Temukan bentuk yang meminimalkan "segi empat" guntingan, lalu dengan ukuran guntingan.
• Ganti setiap karakter dalam bentuk program dengan karakter yang sesuai di input program.

Membongkar, tidak diserang, dan berkomentar sepertinya ini.

                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

Jalankan yang ini

Arang , 120 byte

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

Cobalah online!Tautan adalah untuk mengucapkan versi kode. Penjelasan:

≔Ｅ⮌⪫⪪Ｓ ωιθ

Lepaskan spasi dari input, lalu balikkan dan pisahkan menjadi karakter, sehingga kita dapat mengulangi karakter dengan lebih mudah nanti.

≔⁰η

Mulai dengan ukuran nol, yang menunjukkan tidak ada hasil yang ditemukan (belum).

Ｆ⊕Ｌθ

Periksa semua panjang sisi hingga panjang tali. (Melempar divisi tentu saja akan membuat kode lebih cepat.)

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

Jika hasilnya ternyata kotak yang sempurna maka simpan ukuran kotak dan juga tetapkan itu sebagai ukuran batas.

Ｆ⊘ιＦ⊕κ

Lingkarkan di atas ketinggian dan lebar batas yang mungkin (lebar batas tidak lebih besar dari tinggi batas, membuat tinggi celah tidak lebih besar dari lebar celah.)

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

Jika ukuran batas adalah panjang yang diinginkan dan kami belum memiliki solusi atau belum sebesar solusi ini, perbarui solusi dengan ukuran persegi dan batas ini.

¿η«

Jika kita punya solusi ...

ＵＯη#

Gambarlah persegi panjang karakter sewenang-wenang dari ukuran persegi yang diberikan.

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

Jika batasnya cukup kecil untuk meninggalkan celah, maka hapus celah itu. (Perintah menggambar akan menggambar ke atas dan ke kiri untuk nilai negatif dan sama sekali tidak menyukai nilai nol.)

ＵＭＫＡ⊟θ

Ganti semua (sisa) karakter dengan karakter dari input.

»:~(

Jika tidak, output :~(.

Jelly , 91 85 byte

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

Cobalah online!

Tautan monadik yang menggunakan string input sebagai argumennya dan mengembalikan string baik dengan output yang diformat atau :~(.

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

Cobalah online!

Menggunakan perbandingan daftar leksikografis Python dengan menggunakan nilai yang sama untuk memilih solusi dan mencetaknya. Saya cukup yakin 10 4 2 atau lebih byte masih bisa dicukur.

Penjelasan

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

Hapus spasi putih dengan memisahkan dengan spasi putih dan bergabung dengan "", lalu konversikan input ke daftar untuk nanti. Juga inisialisasi ldengan panjang kode aktual dan pdaftar kemungkinan yang valid.

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

Lingkari semua kemungkinan ukuran celah dari 0*0hingga l*l. Hitung panjang tepi kotak dengan lkarakter kode dan x*yspasi sebagai s.

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

Periksa apakah kondisi berikut cocok:

• s % 1 == 0, yaitu kuadrat sempurna akan terbentuk
• x < s-1 > y, yaitu xdan ypaling banyak s-2dan muat di dalam kotak
• s % 2 == x % 2 == y % 2, yaitu keduanya xdany cocok dengan paritas tepi dan dapat dipusatkan
• tetapi jika x < 1, yaitu x == 0, abaikan semua kecuali persyaratan kuadrat yang sempurna

Jika kondisinya cocok, tambahkan item berikut dalam tuple puntuk menemukan yang optimal:

• abs(x-y)/2; pertama-tama temukan perbedaan minimal xdan yuntuk mendapatkan celah paling persegi. Ini selalu jadi kami membagi 2.
• int(s); selanjutnya temukan panjang sisi minimal. Karena smerupakan bilangan bulat dan bertambah sebagai area gap x*y, ini mengurutkan berdasarkan area gap.
• -x; selanjutnya temukan lebar maksimal untuk memilih celah horisontal. Ini muncul setelah area karena bagaimana ia dikembangkan, tetapi area itu sama untuk x*ydan y*xjadi itu berfungsi.

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

Jika kami menemukan tata letak yang valid, temukan tata letak yang optimal seperti dijelaskan di atas. Hitung batas horizontal bdan inisialisasi nomor baris Yke 0.

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

Jika nomor garis Yberada di dalam celah (batas vertikal b+d, dengan ddari tuple), tambahkan nilai jarak lebar celah setelah batas horizontal masuk c. (Modifikasi cadalah mengapa kita membutuhkannya menjadi daftar.) Kemudian cetaklah garis bujur sangkar dan hapus dari c. Ulangi skali, menambah nomor baris.

else:print':~('

Jika tidak ada tata letak yang ditemukan, gagal.

Pyth , 99 98 byte

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

Cobalah online!

Ini menggunakan algoritma yang sama dengan jawaban Python saya, tetapi banyak detail diubah secara signifikan menjadi lebih pendek di Pyth.

Pyth menunjukkan umurnya di sini, karena umurnya belum diperbarui dan hanya menggunakan karakter ASCII yang dapat dicetak (untuk kode, bukan data), menghabiskan banyak ruang.

Menariknya, jika Pyth menggunakan kemasan base-256 yang sama dengan Stax, program ini bisa ⌈98 log ₂₅₆ 95⌉ = 81 byte panjang, tepat di sebelah Stax (80 byte) dan Jelly (85 byte). Saya pikir ini dengan baik menunjukkan seberapa dekat bahasa golf bahkan dengan paradigma mereka yang sangat berbeda.

Penjelasan (hanya sedikit kurang terbaca dari kode)

#membungkus segala sesuatu dalam while True:yang menekan pesan dan berhenti karena kesalahan.

JscQ) chop masukan ( Q) di spasi putih, sums bagian bersama-sama dan menyimpan hasilnya J.

^UJ2membuat daftar indeks ( U) dari Jdan mengambil 2kekuatan Kartesius ( ^), menghasilkan semua pasangan [h,w]dengan 0<=h<len(J)dan 0<=w<len(J).

+L@+lJ*Fd: untuk semua ( L) pasangan tersebutd , tambahkan ( +) akar kuadrat ( @... 2) dari ( length of Jplus ( +) produk ( *F) dari pasangan d) ke sisi kiri pasangan, membuat triplet [side length, gap height, gap width].

f!|%hT1&eT|t{%R2TgeStThT: filter untuk kembar tiga di Tmana

• tak satu pun dari ( !|):
  • panjang sisi ( hT) modulo 1 ( %... 1) adalah nol
  • keduanya ( &):
    • tinggi celah ( eT) bukan nol
    • salah satu dari ( |):
      • setiap angka dalam triplet ( R) modulo 2 ( %…2 ), dengan duplikat ( {) dan unik pertama ( t) dihapus, adalah kosong
      • semakin besar ( eS) tinggi celah dan lebar celah ( tT) adalah greater-atau-sama dengan panjang sisi ( hT)

Smengurutkan kembar tiga secara leksikografis (dengan panjang sisi, kemudian dengan tinggi celah). oaFtNkemudiano menaiki kembar tiga oleh aperbedaan bsolute antara tinggi celah dan lebar celah (tN ).

Pada titik ini, jika kami tidak memiliki solusi yang valid, |evaluasi argumen keduanya \n":~(", yang mencetak dan mengembalikan :~(. hmengambil solusi optimal (atau ":"jika tidak ada) dan disimpan dalam K. Kemudian hmengambil sisi panjangnya (atau ":"jika tidak ada),s melemparkannya ke integer (atau gagal dan berhenti jika tidak ada) dan disimpan ( =) diQ .

Masing-masing ( m) [gap height, gap width]( tK) kemudian dikurangi ( -) dari panjang sisi ( Q) dan hasilnya dibagi 2 ( /... 2). Hasilnya Aditandatangani ke Gdan H.

Akhirnya, kita memasuki Wlingkaran hile. Zmulai dari 0 dan setiap iterasi kita tambahkan tetapi gunakan nilai lama ( ~hZ, pikirkan Z++dalam C).

• Jika ( W) nilai lama ada di ( {) range Gto (panjang sisi - G) ( -QG), tetapkan ( =) Jsebagai berikut: chop Jat position ( ]) Hdan join bagian dengan lebar eKkali celah ( *) spasi ( d) spasi ( ). Jika nilainya tidak dalam kisaran, kembalilah saja J. Jika hasil ini kosong, hentikan loop.
• Hapus ( >) Qkarakter pertama dari Jdan tetapkan ( ~) hasilnya untuk J. Dari nilai lama J, ambil ( <) Qkarakter pertama dan cetak.

Akhirnya, #loop dimulai lagi, kesalahan dan berhenti karena cQ)dengan Qberisi angka tidak valid.

05AB1E , 95 89 byte

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

Beberapa byte di sana-sini pasti bisa bermain golf.

Tiga langkah pertama dari program ini terinspirasi oleh jawaban Stax dari @recursive , jadi pastikan untuk meningkatkannya!

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

Langkah 1: Hapus semua spasi putih:

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

Langkah 2: Buat semua kembar tiga yang mungkin $[a,b,c]$dimana $a$ adalah dimensi yang dihasilkan $a×a$ persegi, dan $b×c$adalah ukuran celahnya. Kami melakukan ini dengan membuat semua kembar tiga yang mungkin menggunakan bilangan bulat di kisaran$[0,a]$. Dan kemudian kami menyaring ini di mana semua hal berikut adalah benar untuk triplet:

• $a^2-b×c=L$dimana $L$ adalah panjang dari string
• $(a\gt b)\text{ and }(a\gt c)$
• $(a\pmod2=b\pmod2=c\pmod2)\text{ or }(min(a,b)\neq0)$

Sebagai contoh: $L=28$akan menghasilkan kembar tiga [[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

Langkah 3: Periksa apakah masih ada anak kembar tiga yang tersisa. Jika tidak, hasilkan ":~("; jika ya, tentukan yang mana yang akan digunakan dengan menyortir dan hanya meninggalkan yang pertama. Kami melakukan ini dengan menyortir tupel$(abs(b-c),b×c)$.

Sebagai contoh: kembar tiga [[6,2,4],[6,4,2],[8,6,6]]akan disortir [[8,6,6],[6,2,4],[6,4,2]], setelah itu hanya [8,6,6]tersisa.

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

Langkah 4: Buat daftar tentang bagaimana kita harus membagi string untuk memasukkan spasi. Ini dilakukan seperti ini:

Diberikan $[a,b,c]$, buat daftar dengan:

• Sebagai item pertama: $\frac{a-b}{2}×a + \frac{a-c}{2}$
• Sebagai tengah $b-1$ item: ${a-c}$
• Sebagai item terakhir: $a^2$

Sebagai contoh: triplet [7,3,5]akan menghasilkan daftar [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`

Langkah 5: Dan akhirnya kami membagi string berdasarkan daftar ini, bergabung kembali bersama $c$ jumlah ruang, membaginya menjadi beberapa bagian $c$, dan bergabunglah bersama-sama dengan baris baru. Sebagai contoh:

String "Alongtesttoseeifitworksasintended."membagi menurut daftar [15,2,2,35]akan menghasilkan: ["Alongtesttoseei","fi","tw","orksasintended."]. Ini kemudian bergabung dengan$c=5$jumlah ruang untuk "Alongtesttoseei fi tw orksasintended.". Dan kemudian dipecah menjadi beberapa bagian ukuran$a=7$untuk ini: ["Alongte","sttosee","i f","i t","w o","rksasin","tended."]. Yang kemudian bergabung dengan baris baru ke keluaran.

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