Alice è stagista in un'azienda che utilizza Brainfuck come lingua principale per lo sviluppo sia lato client che lato server. Alice ha appena scritto il suo primo codice ed è un po 'nervosa mentre si prepara per la sua prima recensione.

Alice vuole rendere il suo codice formattato correttamente e avere un bell'aspetto, ma non ha tempo di leggere la guida sullo stile del codice aziendale di 328 pagine, quindi ha deciso di formattarlo come un quadrato perfetto . Purtroppo, la lunghezza del codice potrebbe essere insufficiente per formare un quadrato, quindi ha deciso di lasciare una fessura rettangolare nel mezzo. Gli spazi vuoti devono essere perfettamente centrati e vicini al quadrato .

Esempi

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

Perfect         OK         Acceptable   Unacceptable    No way!        Nope.

Scrivi un programma o una funzione per aiutare Alice. Dato il codice di Alice come stringa di input, se possibile emetti codice correttamente formattato come descritto di seguito. Se la formattazione è impossibile, emetti emoji piangenti :~(.

Si tratta di code-golf, quindi le risposte sono classificate in byte con l'obiettivo di ottenere meno byte.

vincoli

1. Il tuo programma o funzione dovrebbe prendere una singola stringa come input e produrre una o più righe di testo (o restituire una stringa a più righe o un array di stringhe, se implementi una funzione).
2. La stringa di input può contenere qualsiasi carattere ASCII inclusi gli spazi bianchi.
3. Tutti gli spazi bianchi in input devono essere ignorati. Non dovrebbero contare per la lunghezza del codice e non dovrebbero essere usati nell'output.
4. La stringa di input contiene almeno un carattere non bianco.
5. Il codice formattato deve avere gli stessi caratteri non bianchi nello stesso ordine del codice di input.
6. Il codice formattato deve essere un quadrato perfetto, ovvero tutte le righe devono avere la stessa lunghezza e il numero di righe deve essere uguale alla lunghezza delle righe.
7. Il codice formattato può contenere uno spazio nel mezzo.
8. Nell'intervallo possono essere utilizzati solo caratteri spaziali (codice ASCII 32).
9. Il divario (se presente) deve essere rettangolare.
10. Ogni riga di codice formattato deve contenere almeno un carattere non bianco, ovvero la larghezza dello spazio deve essere strettamente inferiore alla larghezza quadrata (lo spazio 5x1 è inaccettabile per 5x5 quadrati).
11. Lo spazio dovrebbe essere orizzontale, ovvero la larghezza dello spazio dovrebbe essere maggiore o uguale all'altezza dello spazio.
12. Il divario deve essere perfettamente centrato.
13. Di conseguenza la larghezza dello spazio e la parità di altezza dovrebbero essere uguali alla parità dello spazio quadrato (ad esempio per lo spazio quadrato 5x5 può essere 1x1, 3x1 o 3x3).
14. Se possibile, output quadrato senza alcun gap.
15. In caso di soluzioni multiple, scegline una con il gap più vicino al quadrato, ovvero la differenza tra larghezza del gap e altezza del gap è minima (ad esempio: il gap 10x10 è più preferibile rispetto a 8x6 e 8x6 è più preferibile rispetto a 6x2).
16. Se c'è ancora un pareggio, scegli la soluzione con un'area minima del gap (ad esempio il gap 2x2 è più preferibile del 4x4).
17. Se è impossibile formattare il codice, emettere :~(.
18. Newline dopo l'ultima riga è facoltativo.
19. [Nuovo] Puoi tranquillamente supporre che qualsiasi carattere con un codice inferiore a 33 sia uno spazio bianco. Spero che ti possa aiutare a giocare a golf.

test

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

Test difficili

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

risorse

Per risparmiare spazio è possibile trovare codice di esempio e casi di test aggiuntivi su tio.run

[Nuovo] Puoi dare un'occhiata alla tabella delle soluzioni accettate per input fino a 100 caratteri . Ho scambiato larghezza e altezza perché sembra più intuituve.

Ispirato da: un quadrato di testo

I cambiamenti

• Aggiunti 2 test, corretto bug nel codice di esempio.

• Aggiunta tabella di soluzioni fino a 100, aggiunta di chiarimenti sugli spazi bianchi.

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

Provalo online!

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

4 byte salvati grazie a @Shaggy

Restituisce una matrice di stringhe.

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

Provalo online!

Stax , 80 byte

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

Esegui ed esegui il debug

Come funziona?

• Considera tutti i quadrati con ritagli rettangolari.
• Filtra le forme del programma che non sono della giusta dimensione.
• Filtra le forme del programma che non hanno la parità corrispondente.
• Filtra le forme del programma in cui il ritaglio è troppo grande per il quadrato.
• Se non ne viene trovato nessuno, l'output fallisce e si chiude.
• Trova la forma che minimizza la "regolarità" del ritaglio, quindi in base alla dimensione del ritaglio.
• Sostituisci ogni carattere nella forma del programma con il carattere corrispondente nell'input del programma.

Disimballato, ungolfed e commentato sembra così.

                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

Esegui questo

Carbone , 120 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

≔Ｅ⮌⪫⪪Ｓ ωιθ

Rimuovere gli spazi dall'input, quindi invertirlo e dividerlo in caratteri, in modo da poterlo ricoprire più facilmente in seguito.

≔⁰η

Inizia con una dimensione pari a zero, indicando che nessun risultato è stato trovato (ancora).

Ｆ⊕Ｌθ

Controlla tutte le lunghezze laterali fino alla lunghezza della corda. (Lanciare una divisione in ovviamente renderebbe il codice più veloce.)

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

Se il risultato risulta essere un quadrato perfetto, salva le dimensioni del quadrato e impostale anche come dimensione del bordo.

Ｆ⊘ιＦ⊕κ

Passa sopra le possibili altezze e larghezze del bordo (la larghezza del bordo non è maggiore dell'altezza del bordo, rendendo l'altezza del gap non superiore alla larghezza del gap.)

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

Se la dimensione del bordo è la lunghezza desiderata e non abbiamo ancora una soluzione o non è così quadrata come questa soluzione, allora aggiorna la soluzione con questo quadrato e le dimensioni del bordo.

¿η«

Se abbiamo una soluzione ...

ＵＯη#

Disegna un rettangolo di un carattere arbitrario delle dimensioni quadrate indicate.

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

Se il bordo è abbastanza piccolo da lasciare uno spazio, allora cancella lo spazio. (Il comando di disegno disegnerà verso l'alto e verso sinistra per valori negativi e non gradisce affatto i valori zero.)

ＵＭＫＡ⊟θ

Sostituisci tutti i caratteri (rimanenti) con i caratteri dell'input.

»:~(

Altrimenti uscita :~(.

Gelatina , 91 85 byte

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

Provalo online!

Un collegamento monadico che accetta la stringa di input come argomento e restituisce una stringa con l'output formattato o :~(.

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

Provalo online!

Utilizza il confronto dell'elenco lessicografico di Python utilizzando gli stessi valori sia per la scelta di una soluzione che per la sua stampa. Sono abbastanza sicuro che circa 10 4 2 byte possano ancora essere eliminati.

Spiegazione

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

Rimuovi gli spazi bianchi suddividendoli con gli spazi bianchi e unendoli a "", quindi converti l'input in un elenco per dopo. Inizializza anche la llunghezza del codice effettivo e pl'elenco delle possibilità valide.

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

Passa attraverso tutte le possibilità di dimensioni del gap da 0*0a l*l. Calcola la lunghezza del bordo del quadrato con i lcaratteri del codice e gli x*yspazi come s.

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

Verifica se le seguenti condizioni corrispondono:

• s % 1 == 0, cioè si formerebbe un quadrato perfetto
• x < s-1 > y, cioè xe ysono al massimo s-2e si adattano all'interno della piazza
• s % 2 == x % 2 == y % 2, cioè entrambi xey corrispondono alla parità del bordo e possono essere centrati
• ma se x < 1, ad esempio x == 0, ignori tutto tranne il requisito quadrato perfetto

Se le condizioni corrispondono, aggiungi i seguenti elementi in una tupla pper trovare quello ottimale:

• abs(x-y)/2; per prima cosa trova la minima differenza di xe yper ottenere il gap più quadrato. Questo è sempre anche così dividiamo per 2.
• int(s); poi trova la lunghezza laterale minima. Poiché sè un numero intero e aumenta come area di gap x*y, questa ordina per area di gap.
• -x; poi trova la larghezza massima per preferire gli spazi orizzontali. Questo viene dopo l'area a causa di come è stata sviluppata, ma l'area è la stessa per x*ye y*xquindi funziona.

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

Se abbiamo trovato layout validi, trova quello ottimale come descritto sopra. Calcola il bordo orizzontale be inizializza il numero di riga Ysu 0.

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

Se il numero di riga si Ytrova all'interno dello spazio (il bordo verticale è b+d, con ddalla tupla), aggiungi gli spazi della larghezza dello spazio dopo il bordo orizzontale c. (La modifica di cè il motivo per cui abbiamo bisogno che sia un elenco.) Quindi stampare una linea del quadrato e rimuoverlo da c. Ripetere i stempi, incrementando il numero di riga.

else:print':~('

Se non sono stati trovati layout, non riesci.

Pyth , 99 98 byte

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

Provalo online!

Questo utilizza lo stesso algoritmo della mia risposta Python, ma molti dettagli sono significativamente modificati per essere più brevi in ​​Pyth.

Pyth mostra la sua età qui, dal momento che non è stato aggiornato da secoli e utilizza solo i caratteri ASCII stampabili (per codice, non dati), sprecando molto spazio.

È interessante notare che se Pyth utilizzava lo stesso tipo di impacchettamento base-256 di Stax, questo programma poteva essere log98 log ₂₅₆ 95⌉ = 81 byte, proprio accanto a Stax (80 byte) e Jelly (85 byte). Penso che questo mostri bene quanto siano vicine le lingue del golf anche con i loro paradigmi drasticamente diversi.

Spiegazione (solo leggermente meno illeggibile del codice)

#racchiude tutto in una while True:che sopprime il messaggio e si chiude in caso di errore.

JscQ) csalta input ( Q) negli spazi bianchi, sunisce le parti e salva il risultatoJ .

^UJ2 rende l'elenco degli indici (U ) di Je prende il suo 2potere cartesiano ( ^), risultando in tutte le coppie [h,w]con 0<=h<len(J)e0<=w<len(J) .

+L@+lJ*Fd: per tutte ( L) tali coppie d, aggiunge ( +) la radice quadrata ( @... 2) di (ill ength di Jplus ( +) il prodotto ( *F) della coppia d) sul lato sinistro della coppia, creando una tripletta [side length, gap height, gap width].

f!|%hT1&eT|t{%R2TgeStThT: filter per terzine Tdove

• nessuno dei ( !|):
  • la lunghezza laterale ( hT) modulo 1 ( %… 1) è diversa da zero
  • entrambi ( &):
    • gap gap ( eT) è diverso da zero
    • entrambi (| ):
      • ogni numero nel triplet ( R) modulo 2 ( %... 2), con duplicati ({ ) e il primo unico ( t) rimosso, non è vuoto
      • il più grande ( eS) dell'altezza e dell'ampiezza ( tT) è gpiù o meno uguale alla lunghezza laterale ( hT)

Sordina le triplette lessicograficamente (per lunghezza laterale, quindi per altezza spazio). oaFtNquindi omostra le terzine in base alla adifferenza assoluta tra altezza e larghezza del gap (tN ).

A questo punto, se non abbiamo soluzioni valide, |valuta il suo secondo argomento \n":~(", che stampa e restituisce :~(. hprende la soluzione ottimale (o ":"se nessuna) e viene salvata K. Quindi hprende la sua lunghezza laterale (o ":"se nessuna), la slancia in numero intero (o fallisce e si chiude se nessuna) e viene salvata ( =) inQ .

Ciascuno di ( m) [gap height, gap width]( tK) viene quindi sottratto ( -) dalla lunghezza laterale ( Q) e il risultato diviso per 2 ( /… 2). I risultati sono Aassegnati a Ge H.

Infine, entriamo in un Wciclo hile. Zinizia da 0 e ogni iterazione lo incrementiamo ma usiamo il vecchio valore ( ~hZ, pensa Z++in C).

• Se ( W) il vecchio valore è in ( {) rnell'angolazione Gdi (lunghezza laterale - G) ( -QG), assegnare ( =) a Jquanto segue: chop Jat position ( ]) He jnelle metà con gap gap eKvolte ( *) uno spazio (d ). Se il valore non era compreso nell'intervallo, ritorna J. Se questo risultato è vuoto, interrompere il ciclo.
• Rimuovere ( >) i primi Qcaratteri da Je assegnare ( ~) il risultato a J. Dal vecchio valore di J, prendi ( <) i primi Qcaratteri e stampali.

Infine, il #ciclo ricomincia, errori e si chiude perché cQ)con Qcontenere un numero non è valido.

05AB1E , 95 89 byte

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

Alcuni byte qua e là possono sicuramente essere giocati a golf.

I primi tre passaggi del programma sono ispirati alla risposta Stax di @recursive , quindi assicurati di votarlo!

Provalo online o verifica tutti i casi di test .

Spiegazione:

Passaggio 1: rimuovere tutti gli spazi bianchi:

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

Passaggio 2: creare tutte le terzine possibili $[a,b,c]$, dove $a$ è la dimensione del risultato $a×a$ piazza e $b×c$è la dimensione del divario. Lo facciamo creando tutte le possibili terzine usando numeri interi nell'intervallo$[0,a]$. E poi li filtriamo dove tutto quanto segue è vero per la tripletta:

• $a^2-b×c=L$, dove $L$ è la lunghezza della stringa
• $(a\gt b)\text{ and }(a\gt c)$
• $(a\pmod2=b\pmod2=c\pmod2)\text{ or }(min(a,b)\neq0)$

Per esempio: $L=28$comporterà le terzine [[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

Passaggio 3: controlla se ci sono ancora tre terzine. In caso contrario, output ":~("; se lo facciamo, determiniamo quale utilizzare ordinando e lasciando solo il primo. Lo facciamo ordinando le tuple$(abs(b-c),b×c)$.

Ad esempio: le terzine [[6,2,4],[6,4,2],[8,6,6]]verranno ordinate in [[8,6,6],[6,2,4],[6,4,2]], dopo di che [8,6,6]rimane solo .

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

Passaggio 4: creare un elenco su come dividere la stringa per inserire gli spazi. Questo viene fatto in questo modo:

Dato $[a,b,c]$, crea un elenco con:

• Come primo articolo: $\frac{a-b}{2}×a + \frac{a-c}{2}$
• Nel mezzo $b-1$ elementi: ${a-c}$
• Come ultimo articolo: $a^2$

Ad esempio: la tripletta [7,3,5]comporterà l'elenco [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`

Passaggio 5: E infine abbiamo diviso la stringa in base a questo elenco, unendola di nuovo insieme $c$ quantità di spazi, dividerlo in parti di dimensioni $c$e unisciti a quelli di newline. Per esempio:

String "Alongtesttoseeifitworksasintended."diviso in base alla lista [15,2,2,35]si tradurrà in: ["Alongtesttoseei","fi","tw","orksasintended."]. A questo si aggiunge$c=5$quantità di spazi per "Alongtesttoseei fi tw orksasintended.". E poi diviso in parti di dimensioni$a=7$a questo: ["Alongte","sttosee","i f","i t","w o","rksasin","tended."]. Che viene poi unito da newline per l'output.

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