Alice ist Praktikantin in einem Unternehmen, das Brainfuck sowohl für die clientseitige als auch für die serverseitige Entwicklung als Hauptsprache verwendet. Alice hat gerade ihren ersten Code geschrieben und ist etwas nervös, als sie sich auf ihre erste Codeüberprüfung vorbereitet.

Alice möchte ihren Code korrekt formatieren und gut aussehen lassen, hat aber keine Zeit, den 328-seitigen Style-Guide für Unternehmenscodes zu lesen, und hat sich daher entschieden, ihn als perfektes Quadrat zu formatieren . Leider kann die Codelänge nicht ausreichen, um ein Quadrat zu bilden, und sie hat beschlossen, eine rechteckige Lücke in der Mitte zu lassen. Die Lücken müssen perfekt zentriert und so quadratisch wie möglich sein.

Beispiele

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

Perfect         OK         Acceptable   Unacceptable    No way!        Nope.

Schreiben Sie ein Programm oder eine Funktion, um Alice zu helfen. Geben Sie den Code von Alice als Eingabezeichenfolge aus und formatieren Sie ihn nach Möglichkeit wie unten beschrieben. Wenn die Formatierung nicht möglich ist, geben Sie einen weinenden Emoji aus :~(.

Dies ist Code-Golf, also werden Antworten in Bytes gewertet, wobei weniger Bytes das Ziel sind.

Einschränkungen

1. Ihr Programm oder Ihre Funktion sollte eine einzelne Zeichenfolge als Eingabe und Ausgabe einer oder mehrerer Textzeilen verwenden (oder eine mehrzeilige Zeichenfolge oder ein Array von Zeichenfolgen zurückgeben, wenn Sie eine Funktion implementieren).
2. Die Eingabezeichenfolge kann beliebige ASCII-Zeichen einschließlich Leerzeichen enthalten.
3. Alle Leerzeichen in der Eingabe müssen ignoriert werden. Sie sollten nicht für die Codelänge zählen und nicht für die Ausgabe verwendet werden.
4. Die Eingabezeichenfolge enthält mindestens ein Nicht-Leerzeichen.
5. Der formatierte Code muss die gleichen Nicht-Leerzeichen in der gleichen Reihenfolge wie der eingegebene Code enthalten.
6. Der formatierte Code muss ein perfektes Quadrat sein, dh alle Zeilen sollten die gleiche Länge haben und die Anzahl der Zeilen sollte der Länge der Zeilen entsprechen.
7. Formatierter Code kann eine Lücke in der Mitte enthalten.
8. In der Lücke dürfen nur Leerzeichen (ASCII-Code 32) verwendet werden.
9. Der Spalt (falls vorhanden) muss rechteckig sein.
10. Jede Zeile des formatierten Codes muss mindestens ein Nicht-Leerzeichen enthalten, dh die Lückenbreite muss unbedingt kleiner als die Quadratbreite sein (Lücke 5x1 ist für 5x5 Quadrat nicht akzeptabel).
11. Der Spalt sollte horizontal sein, dh die Spaltbreite sollte größer oder gleich der Spalthöhe sein.
12. Der Spalt muss perfekt zentriert sein.
13. Folglich sollten die Lückenbreiten- und -höhenparität mit der Quadratbreitenparität identisch sein (beispielsweise kann die Lücke für 5 × 5 Quadrate 1 × 1, 3 × 1 oder 3 × 3 betragen).
14. Wenn möglich, Quadrat ohne Lücke ausgeben.
15. Wählen Sie bei mehreren Lösungen eine Lösung mit einer Lücke, die dem Quadrat am nächsten liegt, dh der Unterschied zwischen Lückenbreite und Lückenhöhe ist minimal (zum Beispiel: Lücke 10x10 ist vorzuziehen als 8x6 und 8x6 ist vorzuziehen als 6x2).
16. Wenn immer noch ein Gleichstand besteht, wählen Sie eine Lösung mit minimaler Lückenfläche (z. B. Lücke 2x2 ist vorzuziehen gegenüber 4x4).
17. Wenn es nicht möglich ist, Code zu formatieren, wird ausgegeben :~(.
18. Zeilenumbruch nach letzter Zeile ist optional.
19. [Neu] Sie können davon ausgehen, dass jedes Zeichen mit einem Code unter 33 ein Leerzeichen ist. Ich hoffe es hilft dir beim Golfen.

Tests

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

Heikle Tests

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

Ressourcen

Aus Platzgründen finden Sie auf tio.run Beispielcode und zusätzliche Testfälle

[Neu] Sie können sich die Tabelle der akzeptierten Lösungen für Eingaben mit bis zu 100 Zeichen ansehen . Ich habe Breite und Höhe vertauscht, weil es intuitiver zu wirken scheint.

Inspiriert von: Ein Quadrat aus Text

Änderungen

• 2 Tests hinzugefügt, Fehler im Beispielcode behoben.

• Es wurde eine Tabelle mit Lösungen bis zu 100 hinzugefügt und eine Klarstellung der Leerstellen hinzugefügt.

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

Probieren Sie es online!

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

4 Bytes gespart dank @Shaggy

Gibt ein Array von Zeichenfolgen zurück.

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

Probieren Sie es online!

Stax , 80 Bytes

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

Führen Sie es aus und debuggen Sie es

Wie funktioniert es?

• Betrachten Sie alle Quadrate mit rechteckigen Ausschnitten.
• Filtern Sie Programmformen heraus, die nicht die richtige Größe haben.
• Filtern Sie Programmformen heraus, die keine übereinstimmende Parität aufweisen.
• Programmformen herausfiltern, bei denen der Ausschnitt für das Quadrat zu groß ist.
• Wenn keine gefunden werden, wird die Ausgabe fehlgeschlagen und beendet.
• Suchen Sie nach der Form, die die "Rechteckigkeit" des Ausschnitts minimiert, und dann nach der Größe des Ausschnitts.
• Ersetzen Sie jedes Zeichen in der Programmform durch das entsprechende Zeichen in der Programmeingabe.

Ausgepackt, ungolfed und kommentiert sieht es so aus.

                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

Führen Sie dieses aus

Holzkohle , 120 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

≔Ｅ⮌⪫⪪Ｓ ωιθ

Entfernen Sie die Leerzeichen aus der Eingabe, kehren Sie sie um und teilen Sie sie in Zeichen auf, damit wir die Zeichen später leichter durchlaufen können.

≔⁰η

Beginnen Sie mit einer Größe von Null, was anzeigt, dass (noch) kein Ergebnis gefunden wurde.

Ｆ⊕Ｌθ

Überprüfen Sie alle Seitenlängen bis zur Länge der Zeichenfolge. (Wenn Sie eine Division einfügen, wird der Code natürlich schneller.)

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

Wenn das Ergebnis ein perfektes Quadrat ist, speichern Sie die Größe des Quadrats und legen Sie diese als Rahmengröße fest.

Ｆ⊘ιＦ⊕κ

Überschleife die möglichen Randhöhen und -breiten (die Randbreite ist nicht größer als die Randhöhe, sodass die Lückenhöhe nicht größer als die Lückenbreite ist.)

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

Wenn die Größe des Rahmens der gewünschten Länge entspricht und wir noch keine Lösung haben oder diese nicht so quadratisch ist wie diese Lösung, aktualisieren Sie die Lösung mit diesen Quadrat- und Rahmengrößen.

¿η«

Wenn wir eine Lösung haben ...

ＵＯη#

Zeichnen Sie ein Rechteck aus einem beliebigen Zeichen der angegebenen Quadratgröße.

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

Wenn der Rand klein genug ist, um eine Lücke zu hinterlassen, löschen Sie die Lücke. (Der Zeichenbefehl zeichnet für negative Werte nach oben und links und mag überhaupt keine Nullwerte.)

ＵＭＫＡ⊟θ

Ersetzen Sie alle (verbleibenden) Zeichen durch Zeichen aus der Eingabe.

»:~(

Sonst Ausgabe :~(.

Jelly , 91 85 Bytes

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

Probieren Sie es online!

Eine monadische Verknüpfung, die die Eingabezeichenfolge als Argument verwendet und eine Zeichenfolge mit der formatierten Ausgabe oder zurückgibt :~(.

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

Probieren Sie es online!

Verwendet den lexikografischen Listenvergleich von Python, indem für die Auswahl und den Ausdruck einer Lösung dieselben Werte verwendet werden. Ich bin mir ziemlich sicher, dass 10 4 2 oder so Bytes immer noch abgeschabt werden können.

Erläuterung

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

Entfernen Sie Leerzeichen durch Teilen mit Leerzeichen und Verbinden mit ""und konvertieren Sie die Eingabe in eine Liste für später. Initialisieren Sie auch ldie Länge des tatsächlichen Codes und pdie Liste der gültigen Möglichkeiten.

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

Durchlaufen Sie alle Möglichkeiten der Lückengrößen von 0*0bis l*l. Berechnen Sie die Kantenlänge des Quadrats mit lCodezeichen und x*yLeerzeichen als s.

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

Überprüfen Sie, ob die folgenden Bedingungen zutreffen:

• s % 1 == 0, dh ein perfektes Quadrat würde gebildet
• x < s-1 > y, dh xund ysind höchstens s-2und passen in das Quadrat
• s % 2 == x % 2 == y % 2, dh beide xund ystimmen mit der Parität der Kante überein und können zentriert werden
• aber wenn x < 1, dh x == 0alle außer der perfekten Quadratanforderung ignorieren

Wenn die Bedingungen übereinstimmen, fügen Sie die folgenden Elemente in ein Tupel ein p, um das optimale zu finden:

• abs(x-y)/2; Finden Sie zuerst den minimalen Unterschied von xund yum die quadratischste Lücke zu erhalten. Dies ist immer so, dass wir durch 2 teilen.
• int(s); Als nächstes finden Sie die minimale Seitenlänge. Da ses sich um eine Ganzzahl handelt und die Lückenfläche zunimmt x*y, wird diese nach Lückenfläche sortiert.
• -x; Als nächstes finden Sie die maximale Breite, um horizontale Lücken zu bevorzugen. Dies kommt nach dem Gebiet aufgrund dessen, wie es entwickelt wurde, aber das Gebiet ist das gleiche x*yund y*xso funktioniert es.

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

Wenn wir gültige Layouts gefunden haben, finden Sie das optimale Layout wie oben beschrieben. Berechnen Sie den horizontalen Rand bund initialisieren Sie die Zeilennummer Yauf 0.

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

Wenn sich die Zeilennummer Yinnerhalb der Lücke befindet (der vertikale Rand befindet sich b+d, zusammen mit ddem Tupel), fügen Sie nach dem horizontalen Rand in die Lückenbreite Leerzeichen hinzu c. (Die Änderung von cist, warum wir es brauchen, um eine Liste zu sein.) Dann drucken Sie eine Zeile des Quadrats und entfernen Sie es von c. Wiederholen Sie diese sSchritte, indem Sie die Zeilennummer erhöhen.

else:print':~('

Wenn keine Layouts gefunden wurden, schlagen Sie fehl.

Pyth , 99 98 Bytes

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

Probieren Sie es online!

Dies verwendet den gleichen Algorithmus wie meine Python-Antwort, aber viele Details werden in Pyth erheblich geändert, um kürzer zu sein.

Pyth zeigt hier sein Alter an, da es seit Ewigkeiten nicht mehr aktualisiert wurde und nur die druckbaren ASCII-Zeichen (für Code, nicht für Daten) verwendet, wodurch viel Platz verschwendet wird.

Interessanterweise könnte dieses Programm, wenn Pyth dieselbe Art von Base-256-Packung wie Stax verwendet, 98 log ₂₅₆ 95 = 81 Bytes lang sein, direkt neben Stax (80 Bytes) und Jelly (85 Bytes). Ich denke, das zeigt sehr gut, wie nah Golfsprachen mit ihren drastisch unterschiedlichen Paradigmen sind.

Erklärung (nur etwas weniger unlesbar als der Code)

#Umschließt alles mit einem while True:, der die Nachricht unterdrückt und bei einem Fehler beendet.

JscQ) chops input ( Q) bei Leerzeichen, sums die Teile zusammen und speichert das Ergebnis in J.

^UJ2macht die Liste der Indizes ( U) zu Jund erhält ihre 2nd kartesische Potenz ( ^), was zu allen Paaren [h,w]mit 0<=h<len(J)und führt 0<=w<len(J).

+L@+lJ*Fd: Für alle ( L) solche Paare daddiert ( +) die Quadratwurzel ( @... 2) der (die length von Jplus ( +) , um das Produkt ( *F) des Paares d) auf der linken Seite des Paares, ein Triplett zu schaffen [side length, gap height, gap width].

f!|%hT1&eT|t{%R2TgeStThT: filter für Drillinge Two

• keiner von ( !|):
  • Seitenlänge ( hT) Modulo 1 ( %… 1) ist ungleich Null
  • beide von ( &):
    • Die Lückenhöhe ( eT) ist ungleich Null
    • eines von ( |):
      • Jede Zahl im Triplet ( R) Modulo 2 ( %… 2), bei der Duplikate ( {) und das erste eindeutige ( t) entfernt wurden, ist nicht leer
      • das Größere ( eS) von Spalthöhe und Spaltbreite ( tT) ist ggleich oder gleich der Seitenlänge ( hT)

Ssortiert die Drillinge lexikographisch (nach Seitenlänge, dann nach Spalthöhe). oaFtNAnschließend owerden die Tripletts um den aabsoluten Unterschied zwischen Spalthöhe und Spaltbreite ( tN) geordnet .

Wenn wir zu diesem Zeitpunkt keine gültigen Lösungen haben, wird |das zweite Argument ausgewertet \n":~(", das gedruckt und zurückgegeben wird :~(. hNimmt die optimale Lösung (oder ":"keine) und es wird in gespeichert K. Nimmt hdann die Seitenlänge (oder ":"wenn keine vorhanden ist), swandelt sie in eine Ganzzahl um (oder schlägt fehl und wird beendet, wenn keine vorhanden ist) und wird in gespeichert ( =) Q.

Jedes von ( m) [gap height, gap width]( tK) wird dann -von der Seitenlänge ( Q) abgezogen ( ) und das Ergebnis durch 2 ( /… 2) geteilt. Die Ergebnisse sind Amit Gund gekennzeichnet H.

Schließlich betreten wir eine WHile-Schleife. Zbeginnt bei 0 und wird bei jeder Iteration erhöht, aber der alte Wert wird verwendet ( ~hZsiehe Z++C).

• Wenn ( W) der alte Wert in ( {) die range Gbis (Seitenlänge - G) ( -QG), assign ( =) zu Jdem folgenden: chop Jan der Position ( ]) Hund join die Hälften mit Spaltbreite eKmal ( *) einen Raum ( d). Wenn der Wert nicht im Bereich liegt, kehren Sie einfach zurück J. Wenn dieses Ergebnis leer ist, stoppen Sie die Schleife.
• Entfernen Sie ( >) die ersten QZeichen von Jund weisen Sie ( ~) das Ergebnis zu J. JNehmen Sie aus dem alten Wert von ( <) die ersten QZeichen und drucken Sie sie aus.

Schließlich wird die #wieder Schleife beginnt, Fehler und quitt , denn cQ)mit Qeiner Zahl ist ungültig.

05AB1E , 95 89 Bytes

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

Ein paar Bytes hier und da kann man definitiv golfen.

Die ersten drei Schritte des Programms sind von @recursives Stax-Antwort inspiriert. Stellen Sie also sicher, dass Sie ihn unterstützen!

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

Schritt 1: Alle Leerzeichen entfernen:

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

Zum Beispiel: Die Drillinge [[6,2,4],[6,4,2],[8,6,6]]werden nach sortiert [[8,6,6],[6,2,4],[6,4,2]], danach [8,6,6]bleibt nur noch.

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

Schritt 4: Erstellen Sie eine Liste, wie die Zeichenfolge aufgeteilt werden soll, um die Leerzeichen einzufügen. Das geht so:

$[a,b,c]$

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

Zum Beispiel: Triplett [7,3,5]führt zur Liste [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)