Alice est stagiaire dans une entreprise qui utilise Brainfuck comme langue principale pour le développement côté client et côté serveur. Alice vient d'écrire son premier code et elle est un peu nerveuse alors qu'elle se prépare pour sa première révision de code.

Alice veut que son code soit correctement formaté et joli, mais elle n'a pas le temps de lire le guide de style de code d'entreprise de 328 pages, alors elle a décidé de le formater comme un carré parfait . Hélas, la longueur du code peut être insuffisante pour former un carré, elle a donc décidé de laisser un espace rectangulaire au milieu. Les espaces doivent être parfaitement centrés et aussi proches du carré que possible.

Exemples

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

Perfect         OK         Acceptable   Unacceptable    No way!        Nope.

Écrivez un programme ou une fonction pour aider Alice. Étant donné le code d'Alice en tant que chaîne d'entrée, sortez le code correctement formaté comme décrit ci-dessous si possible. Si le formatage est impossible, sortez les emoji qui pleurent :~(.

Il s'agit de code-golf donc les réponses sont notées en octets avec moins d'octets comme objectif.

Contraintes

1. Votre programme ou fonction doit prendre une seule chaîne en entrée et produire une ou plusieurs lignes de texte (ou renvoyer une chaîne multi-lignes ou un tableau de chaînes, si vous implémentez une fonction).
2. La chaîne d'entrée peut contenir tous les caractères ASCII, y compris les espaces blancs.
3. Tous les espaces blancs en entrée doivent être ignorés. Ils ne doivent pas compter pour la longueur du code et ne doivent pas être utilisés en sortie.
4. La chaîne d'entrée contient au moins un caractère non blanc.
5. Le code formaté doit avoir les mêmes caractères non blancs dans le même ordre que dans le code d'entrée.
6. Le code formaté doit être un carré parfait, c'est-à-dire que toutes les lignes doivent avoir la même longueur et le nombre de lignes doit être égal à la longueur des lignes.
7. Le code formaté peut contenir un espace au milieu.
8. Seuls les espaces (code ASCII 32) peuvent être utilisés dans l'espace.
9. L'écart (s'il est présent) doit être rectangulaire.
10. Chaque ligne de code formaté doit contenir au moins un caractère non blanc, c'est-à-dire que la largeur de l'espace doit être strictement inférieure à la largeur du carré (l'espace 5x1 est inacceptable pour le carré 5x5).
11. L'écart doit être horizontal, c'est-à-dire que la largeur de l'espace doit être supérieure ou égale à la hauteur de l'espace.
12. L'écart doit être parfaitement centré.
13. Par conséquent, la largeur de l'espace et la parité de la hauteur doivent être identiques à la parité de la largeur carrée (par exemple, pour un espace carré de 5x5, il peut s'agir de 1x1, 3x1 ou 3x3).
14. Si possible, émettez un carré sans aucun espace.
15. En cas de solutions multiples, choisissez-en une avec un espace le plus proche du carré, c'est-à-dire que la différence entre la largeur et la hauteur de l'espace est minime (par exemple: l'espace 10x10 est plus préférable que 8x6 et 8x6 est plus préférable que 6x2).
16. S'il y a toujours égalité, choisissez une solution avec une zone d'espace minimale (par exemple, l'espace 2x2 est plus préférable que 4x4).
17. S'il est impossible de formater le code, sortez :~(.
18. La nouvelle ligne après la dernière ligne est facultative.
19. [Nouveau] Vous pouvez sans risque supposer que tout caractère dont le code est inférieur à 33 est un espace blanc. J'espère que cela vous aidera pour le golf.

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

Tests délicats

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

Ressources

Pour économiser de l'espace, vous pouvez trouver des exemples de code et des cas de test supplémentaires sur tio.run

[Nouveau] Vous pouvez consulter le tableau des solutions acceptées pour les entrées jusqu'à 100 caractères . J'ai inversé la largeur et la hauteur car cela semble plus intuitif.

Inspiré par: un carré de texte

Changements

• Ajout de 2 tests, correction d'un bug dans l'exemple de code.

• Ajout d'un tableau de solutions jusqu'à 100, ajout d'une clarification des espaces blancs.

C (gcc) , 354 octets

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

Essayez-le en ligne!

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

4 octets enregistrés grâce à @Shaggy

Renvoie un tableau de chaînes.

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

Essayez-le en ligne!

Stax , 80 octets

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

Exécuter et déboguer

Comment ça marche?

• Considérez tous les carrés avec des découpes rectangulaires.
• Filtrez les formes de programme qui ne sont pas de la bonne taille.
• Filtrez les formes de programme qui n'ont pas de parité correspondante.
• Filtrez les formes de programme où la découpe est trop grande pour le carré.
• Si aucun n'est trouvé, échec de sortie et quitte.
• Trouvez la forme qui minimise la "rectangulaire" de la découpe, puis par taille de découpe.
• Remplacez chaque caractère dans la forme du programme par le caractère correspondant dans l'entrée du programme.

Déballé, non golfé et commenté, cela ressemble à ceci.

                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

Exécutez celui-ci

Charbon de bois , 120 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

≔Ｅ⮌⪫⪪Ｓ ωιθ

Supprimez les espaces de l'entrée, puis inversez-les et divisez-les en caractères, afin que nous puissions boucler plus facilement sur les caractères plus tard.

≔⁰η

Commencez avec une taille de zéro, indiquant qu'aucun résultat n'a (encore) été trouvé.

Ｆ⊕Ｌθ

Vérifiez toutes les longueurs de côté jusqu'à la longueur de la chaîne. (Le fait de jeter une division rendrait bien sûr le code plus rapide.)

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

Si le résultat s'avère être un carré parfait, enregistrez la taille du carré et définissez-le également comme taille de bordure.

Ｆ⊘ιＦ⊕κ

Boucle sur les hauteurs et largeurs de bordure possibles (la largeur de la bordure n'est pas supérieure à la hauteur de la bordure, ce qui fait que la hauteur de l'espace n'est pas supérieure à la largeur de l'espace.)

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

Si la taille de la bordure est la longueur souhaitée et que nous n'avons pas encore de solution ou qu'elle n'est pas aussi carrée que cette solution, mettez à jour la solution avec ces tailles de carré et de bordure.

¿η«

Si nous avons une solution ...

ＵＯη#

Dessinez un rectangle d'un caractère arbitraire de la taille carrée donnée.

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

Si la bordure est suffisamment petite pour laisser un espace, effacez-le. (La commande de dessin dessinera vers le haut et vers la gauche pour les valeurs négatives et n'aime pas du tout les valeurs nulles.)

ＵＭＫＡ⊟θ

Remplacez tous les caractères (restants) par des caractères de l'entrée.

»:~(

Sinon, sortie :~(.

Gelée , 91 85 octets

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

Essayez-le en ligne!

Un lien monadique qui prend la chaîne d'entrée comme argument et renvoie une chaîne avec la sortie formatée ou :~(.

Python 2, 287 281 279 octets

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

Essayez-le en ligne!

Utilise la comparaison de listes lexicographiques de Python en utilisant les mêmes valeurs pour choisir une solution et l'imprimer. Je suis à peu près sûr que 10 4 2 ou plus d'octets peuvent encore être rasés.

Explication

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

Supprimez les espaces blancs en les divisant en espaces blancs et en les rejoignant "", puis convertissez l'entrée en liste pour plus tard. Initialiser également là la longueur du code réel et pà la liste des possibilités valides.

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

Parcourez toutes les possibilités de tailles d'écart de 0*0à l*l. Calculez la longueur du bord du carré avec ldes caractères de code et des x*yespaces comme s.

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

Vérifiez si les conditions suivantes correspondent:

• s % 1 == 0, c'est-à-dire qu'un carré parfait serait formé
• x < s-1 > y, c'est-à x- dire et ysont tout au plus s-2et s'insèrent dans le carré
• s % 2 == x % 2 == y % 2, c'est-à-dire les deux xet ycorrespondent à la parité du bord et peuvent être centrés
• mais si x < 1, c.-à-d. x == 0, ignorer tout sauf l'exigence de carré parfait

Si les conditions correspondent, ajoutez les éléments suivants dans un tuple ppour trouver celui optimal:

• abs(x-y)/2; trouver d'abord la différence minimale de xet ypour obtenir l'écart le plus carré. C'est toujours le cas, donc nous divisons par 2.
• int(s); trouver ensuite la longueur minimale du côté. Puisque sest un entier et augmente en tant que zone d'espace x*y, il trie par zone d'espace.
• -x; trouver ensuite la largeur maximale pour préférer les espaces horizontaux. Cela vient après la zone en raison de la façon dont elle a été développée, mais la zone est la même x*yet y*xfonctionne donc.

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

Si nous avons trouvé des dispositions valides, trouvez celle optimale comme décrit ci-dessus. Calculez la bordure horizontale bet initialisez le numéro de ligne Yà 0.

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

Si le numéro de ligne se Ytrouve à l'intérieur de l'espace (la bordure verticale est b+d, avec ddu tuple), ajoutez la valeur d'espaces de la largeur de l'espace après la bordure horizontale c. (La modification de cest pourquoi nous avons besoin que ce soit une liste.) Imprimez ensuite une ligne du carré et supprimez-la c. Répétez sfois, en incrémentant le numéro de ligne.

else:print':~('

Si aucune disposition n'a été trouvée, échouez.

Pyth , 99 98 octets

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

Essayez-le en ligne!

Cela utilise le même algorithme que ma réponse Python, mais de nombreux détails sont considérablement modifiés pour être plus courts en Pyth.

Pyth montre son âge ici, car il n'a pas été mis à jour depuis des siècles et n'utilise que les caractères ASCII imprimables (pour le code, pas les données), ce qui gaspille beaucoup d'espace.

Fait intéressant, si Pyth utilisait le même type d'emballage de base 256 que Stax, ce programme pourrait être ⌈98 log ₂₅₆ 95⌉ = 81 octets de long, juste à côté de Stax (80 octets) et Jelly (85 octets). Je pense que cela montre bien à quel point les langues de golf sont proches, même avec leurs paradigmes radicalement différents.

Explication (seulement légèrement moins illisible que le code)

#enveloppe tout dans un while True:qui supprime le message et se ferme en cas d'erreur.

JscQ) csaute input ( Q) dans les espaces blancs, place sles parties ensemble et enregistre le résultat dans J.

^UJ2fait la liste des indices ( U) de Jet prend sa 2nd puissance cartésienne ( ^), résultant en toutes les paires [h,w]avec 0<=h<len(J)et 0<=w<len(J).

+L@+lJ*Fd: pour toutes ( L) ces paires d, ajoute ( +) la racine carrée ( @… 2) de (la lvaleur de Jplus ( +) le produit ( *F) de la paire d) au côté gauche de la paire, créant un triplet [side length, gap height, gap width].

f!|%hT1&eT|t{%R2TgeStThT: filtre pour triplets Toù

• ni de ( !|):
  • la longueur du côté ( hT) modulo 1 ( %… 1) est différente de zéro
  • les deux ( &):
    • la hauteur de l'espace ( eT) est différente de zéro
    • soit ( |):
      • chaque numéro du triplet ( R) modulo 2 ( %… 2), avec les doublons ( {) et le premier unique ( t) supprimés, n'est pas vide
      • la plus grande ( eS) de la hauteur et de la largeur de l'espace ( tT) est gplus ou moins égale à la longueur du côté ( hT)

Strie les triplets lexicographiquement (par longueur de côté, puis par hauteur d'écart). oaFtNpuis otrie les triplets par la adifférence absolue entre la hauteur et la largeur de l'espace ( tN).

À ce stade, si nous n'avons pas de solutions valides, |évalue son deuxième argument \n":~(", qui imprime et renvoie :~(. hprend la solution optimale (ou ":"si aucune) et elle est enregistrée dans K. Prend ensuite hsa longueur de côté (ou ":"si aucun), le sconvertit en entier (ou échoue et quitte si aucun) et il est enregistré ( =) dans Q.

Chacun de ( m) [gap height, gap width]( tK) est ensuite soustrait ( -) de la longueur du côté ( Q) et le résultat divisé par 2 ( /… 2). Les résultats sont Asignés pour Get H.

Enfin, nous entrons dans une Wboucle de hile. Zcommence à 0 et à chaque itération nous l'incrémentons mais utilisons l'ancienne valeur ( ~hZ, pensez Z++en C).

• Si ( W) l'ancienne valeur se trouve dans ( {) le point d' rancrage Gà (longueur du côté - G) ( -QG), affectez ( =) à Jce qui suit: csautez Jà la position ( ]) Het jplacez les moitiés avec des intervalles de largeur d'espace eK( *) un espace ( d). Si la valeur n'était pas dans la plage, revenez simplement J. Si ce résultat est vide, arrêtez la boucle.
• Supprimez ( >) les premiers Qcaractères de Jet affectez ( ~) le résultat à J. À partir de l'ancienne valeur de J, prenez ( <) les premiers Qcaractères et imprimez-les.

Enfin, la #boucle recommence, des erreurs et se termine car cQ)avec Qcontenant un nombre n'est pas valide.

05AB1E , 95 89 octets

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

Quelques octets ici et là peuvent certainement être joués.

Les trois premières étapes du programme sont inspirées de la réponse Stax de @recursive , alors assurez-vous de lui donner un vote positif!

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

Étape 1: supprimez tous les espaces blancs:

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

Par exemple: $L=28$entraînera les triplets [[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

Étape 3: Vérifiez s'il nous reste encore des triplets. Sinon, sortie ":~("; si c'est le cas, déterminez lequel utiliser en triant et en ne laissant que le premier. Nous faisons cela en triant les tuples$(abs(b-c),b×c)$.

Par exemple: les triplets [[6,2,4],[6,4,2],[8,6,6]]seront triés [[8,6,6],[6,2,4],[6,4,2]], après quoi il ne [8,6,6]reste que.

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

Étape 4: Créez une liste sur la façon de diviser la chaîne pour insérer les espaces. Cela se fait comme ceci:

Donné $[a,b,c]$, créez une liste avec:

• Comme premier article: $\frac{a-b}{2}×a + \frac{a-c}{2}$
• Au milieu $b-1$ articles: ${a-c}$
• Comme dernier élément: $a^2$

Par exemple: triplet [7,3,5]donnera la 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`

Étape 5: Et enfin, nous avons divisé la chaîne en fonction de cette liste, rejoignez-la avec $c$ quantité d'espaces, divisez-la en parties de taille $c$et réunissez-les par des sauts de ligne. Par exemple:

Chaîne "Alongtesttoseeifitworksasintended."divisé selon la liste [15,2,2,35]se traduira par: ["Alongtesttoseei","fi","tw","orksasintended."]. Ceci est ensuite rejoint par$c=5$nombre d'espaces à "Alongtesttoseei fi tw orksasintended.". Et puis divisé en parties de taille$a=7$à ceci: ["Alongte","sttosee","i f","i t","w o","rksasin","tended."]. Qui est ensuite rejoint par des sauts de ligne pour sortir.

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