Contribution:

Un string

Production:

1) D'abord, nous prenons le caractère de suppression à la fin de la chaîne d'entrée jusqu'à ce qu'il nous reste une longueur qui est un carré (c'est-à-dire 1, 4, 9, 16, 25, 36, etc.)
Donc abcdefghijklmnopqrstuvwxyz(la longueur 26) devient abcdefghijklmnopqrstuvwxy( longueur 25).

2) Ensuite, nous mettons cela dans un carré, une ligne à la fois, de gauche à droite:

abcde
fghij
klmno
pqrst
uvwxy

3) Nous le plions dans les quatre directions, comme ceci (nous continuons à déplier jusqu'à ce que le `` bloc '' plié extérieur n'ait plus de caractères intérieurs à déplier):

      m
     qrs
     l n
     ghi
    abcde
 ihgf   jihg
mn lk   on lm
 srqp   tsrq
    uvwxy
     qrs
     l n
     ghi
      m

Certaines choses à noter, lorsque nous nous replions vers l'extérieur, nous reflétons essentiellement comme ceci (les chiffres ajoutés à titre de clarification, qui représentent les `` index '' dans ces exemples):

Lorsque nous déplions le côté gauche:

 123    to:   321 123
fghij         ihgf   j

Lorsque nous replions le côté droit:

 123    to:    123 321
fghij         f   jihg

Lorsque nous nous replions vers le haut:

            3q
            2l
            1g
  b   to:    b
 1g         1
 2l         2
 3q         3
  v          v

Lorsque nous nous replions vers le bas:

 b          b
1g         1
2l         2
3q         3
 v   to:    v
           3q
           2l
           1g

Règles du défi:

• Vous pouvez supposer que l'entrée aura toujours au moins 1 caractère (qui sera également la sortie).
• Le format de sortie est flexible, vous pouvez donc imprimer sur STDOUT ou STDERR; renvoyer sous forme de tableau / liste de chaînes ou de tableau 2D de caractères; chaîne unique avec des nouvelles lignes; etc.
• L'entrée ne contiendra que des caractères alphanumériques ( a-zA-Z0-9)
• Vous pouvez également utiliser un caractère non alphanumérique pour remplir les espaces dans et / ou autour de la sortie ASCII-art, comme un point ..
• Les espaces de fin et une seule nouvelle ligne de fin sont facultatifs.
• Nous continuons à déplier jusqu'à ce que le «bloc» plié extérieur n'ait plus de centres à déplier.

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues non-golfeur de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

Cas de test:

Input: abcdefghijklmnopqrstuvwxy
Output:
      m
     qrs
     l n
     ghi
    abcde
 ihgf   jihg
mn lk   on lm
 srqp   tsrq
    uvwxy
     qrs
     l n
     ghi
      m

Input: A
Ouput:
A

Input: ThisIsATest
Output:
  I
 Thi
Is sI
 ATe
  I

Input: HowAboutAVeryLongExampleWhichIsAlsoAnEvenSquareInsteadOfOddOneAndExceeds64Chars
Output:

               An
               ch
              xamp
              i  I
              o  E
              quar
             steadO
             S    e
             s    v
             h    s
             E    l
             VeryLo
            HowAbout
      oLyreVA      noLyreV
  xampl    Eg      el    Examp
hci  Is    hW      As    hi  Ihc
nAo  Ev    sl      ev    so  EnA
  quare    Sn      Ie    Squar
      Odaetsn      fOdaets
            OddOneAn
             steadO
             S    e
             s    v
             h    s
             E    l
             VeryLo
              xamp
              i  I
              o  E
              quar
               An
               ch

Input: Lenght7
Output:
Le
ng

Input: abc
Output:
a

SOGL V0.12 , 75 octets

l√u²m√lH»{ā;l⁾:A∫Ba{bIwFIWhFbž;FIbI@ž}};}¹K⁴{ē2\⌡±e{@Κ};⁴┼┼};0E{ē2\⌡№:h++}╚

Essayez-le ici!

Cela attend l'entrée sur la pile, donc pour la facilité d'utilisation, j'ai ajouté ,au début. Cela peut causer des problèmes si l'entrée ne contient que des chiffres, voici donc une suite de tests pour cela.

70 octets √lH»{ā;l⁾:A∫Ba{bIwFIWhFbž;FIbI@ž}};}¹K⁴{ē2\⌡±e{@Κ};⁴┼┼};0E{ē2\⌡№:h++}╚fonctionnent aussi, mais comme je ne l'ai implémenté que √sur des chaînes et que la documentation ne mentionne pas que cela couvrirait la longueur, je ne le compterai pas.

Explication:

creating a square from the input

l       get the length of the input
 √      get its square root
  u     floor that
   ²    square it
    m   mold the input to that length
     √  convert it to a square

creating the unfoldings of the square - the idea is to cut out the inner squares to a new array

lH»{                              } (length-1)//2 times do
    ā;                                push an empty array below ToS
      l⁾                              push ToS.length - 2 (ToS here is the square or the previous unfolding)
        :A                            save a copy of that in the variable A
          ∫B                    }     repeat that amount of times, saving iteration on B - cutting the inner square to the empty array
            a{                 }        variable A times do
              bIw                         get the b+1th row of the previous unfolding
                 FIW                      get the (current loops iteration + 1)th character of that
                    h                     swap the 2 items below ToS - so the stack now is [..., prevUnfolding, newArray, character]
                     Fbž                  at [current loops iteration; b] insert that character in the array
                        ;                 swap the top 2 items - the stack now is [..., newArray, prevUnfolding]
                         FIbI@ž           at [current loops iteration+1; b+1] insert a space
                                 ;    get the now not empty array ontop of the stack

add the horizontal unfoldings

¹                    wrap the stack in an array
 K                   push the 1st item of that, which will function as the canvas
  ⁴{              }  iterate over a copy of the remaining items
    ē2\⌡               repeat (e++ divides by 2) times (default for the variable E is the input, which defaults to 0)
        ±                reverse the array horizontally
         e{  }         repeat e times
           @Κ            add a space before ToS
              ;⁴┼┼     add that horizontally before and after the canvas

add the veertical unfoldings

;                get the copy of the foldings above the canvas
 0E              reset the variable E to 0
   {         }   iterate the copy of the foldings
    ē2\⌡           repeat (e++ divides by 2) times (default for the variable E is the input, which defaults to 0)
        №            reverse the array vertically
         :h++      add that vertically before and after the canvas
              ╚  center the canvas vertically

Charbon de bois , 120 109 octets

ＡＩ§⪪ＩＸＬθ⁰·⁵.⁰ηＦη⊞υ✂θ×ιηＦ⁴«ＡυεＪ⁰¦⁰Ｆ÷⁺¹η²«Ｆ⁴«Ｆ⁻η⁺κꧧεκ⁺μκ↷Ａ⮌ＥεＥε§ξν嶻Ａ⎇﹪ι²Ｅε⮌λ⮌εεＡ⎇‹ι²⁻⁺²⁺κκη⁻η⁺κκκ¿﹪ι²Ｍκ¹Ｍ¹κ

Essayez-le en ligne! Notez que ce dernier Ａa été remplacé par ≔et le lien le reflète. Explication:

       θ          Input string
      Ｌ           Length
     Ｘ  ⁰·⁵       Raise to the power 0.5
    Ｉ             Cast to string
   ⪪       .      Split on the decimal point
  §         ⁰     Take the first element (integer part)
 Ｉ                Cast to integer
Ａ            η    Assign to h

Calcule h = int(sqrt(len(q))). ( Floordevait encore être mis en œuvre ...)

Ｆη⊞υ✂θ×ιη

Extrait les htranches de longueur hde l'entrée. (En fait, je ne prends pas la peine de tronquer les tranches sur la longueur h.) J'utilise une forboucle plutôt qu'un, Mapcar j'ai besoin Assigndu résultat de Mapquelque part et ce n'est pas anodin lorsque l'on traite un Slice.

Ｆ⁴«

Le dépliage se produit 4 fois, une fois pour chaque direction (bas, droite, haut, gauche comme codé). La variable de boucle pour cette boucle est i.

   Ａυε

Prenez une copie de la chaîne tranchée.

   Ｊ⁰¦⁰

Revenez à l'origine du canevas pour que chaque hdépliage commence par le -par- hcarré au même endroit.

   Ｆ÷⁺¹η²«

Répétez (h+1)/2fois; une fois pour chaque dépli, plus une fois pour le carré d'origine. La variable de boucle pour cette boucle est k.

          Ｆ⁴«

Répétez 4 fois, une fois de chaque côté du carré déplié. (Je n'utilise pas la variable de boucle l.)

             Ｆ⁻η⁺κκ         Loop h-2k times, loop variable `m`
                    §εκ     Take the `k`th row
                   §   ⁺μκ  Take the `k+m`th column
                            Implicitly print the character

Imprimez un côté du carré déplié. Puisqu'il s'agit du ktroisième déplié, le côté du carré l'est h-2ket kéloigne les personnages du bord du carré d'origine.

             ↷

Pivot prêt à imprimer le côté suivant du carré.

               Ｅε       Map over the array (element `m`, index `n`)
                 Ｅε     Map over the array (element `x`, index `p`)
                   §ξν  Take the `n`th element of `x`
              ⮌         Reverse
             Ａ        ε Replace the array with the result

Faites pivoter la chaîne tranchée. (Oui, c'est un ξ. Je ne l'utilise pas souvent!) ＥηFonctionnerait également pour l'extérieur Map. La rotation a également pour effet secondaire pratique de tronquer la largeur du tableau à h.

             ¶»

Après avoir imprimé le côté, le curseur se déplace hors du bord du carré. L'impression d'un caractère de moins échoue pour les carrés du côté 1 et est moins golfique de toute façon. Après avoir pivoté précédemment, l'impression d'une nouvelle ligne déplace commodément le curseur dans le coin.

            ﹪ι²         Take `i` modulo 2
           ⎇            Choose either
                   ⮌ε   Reverse the array
               Ｅε       Map over the array (element `l`, index `m`)
                 ⮌λ     Reverse each element
          Ａ          ε  Replace the array with the result

Retournez le carré verticalement ou horizontalement selon le cas.

           ⎇‹ι²                 If `i` < 2
                  ⁺κκ           Double `k`
                ⁺²              Add 2
               ⁻     η          Subtract `h`
                        ⁺κκ     Else double `k`
                      ⁻η        Subtract from `h`
          ≔                κ    Assign back to `k`.

Calculez le déplacement vers le dépliage suivant.

           ﹪ι²          Take `i` modulo 2
          ¿             If not zero
              Ｍκ¹       `k` across and 1 down
                 Ｍ¹κ    Else 1 across and `k` down

Déplacez-vous horizontalement ou verticalement vers le dépliage suivant, selon le cas.

Voici un lien vers la version 97 octets obtenue en utilisant toutes les dernières fonctionnalités de charbon de bois, y compris Floor: Essayez-le en ligne! Le lien est vers la version détaillée du code.