Ingresso:

Una stringa

Produzione:

1) Per prima cosa prendiamo il carattere di rimozione alla fine della stringa di input fino a quando non ci rimane una lunghezza che è un quadrato (cioè 1, 4, 9, 16, 25, 36, ecc.)
Quindi abcdefghijklmnopqrstuvwxyz(lunghezza 26) diventa abcdefghijklmnopqrstuvwxy( lunghezza 25).

2) Quindi inseriamo questo in un quadrato, una riga alla volta, da sinistra a destra:

abcde
fghij
klmno
pqrst
uvwxy

3) Lo pieghiamo in tutte e quattro le direzioni, in questo modo (continuiamo a spiegarci fino a quando il 'blocco' esterno piegato non ha più caratteri interni da dispiegare):

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

Alcune cose da notare, quando pieghiamo verso l'esterno, fondamentalmente rispecchiamo in questo modo (numeri aggiunti come chiarimento, che rappresenta gli "indici" in questi esempi):

Quando apriamo il lato sinistro:

 123    to:   321 123
fghij         ihgf   j

Quando pieghiamo il lato destro:

 123    to:    123 321
fghij         f   jihg

Quando pieghiamo verso l'alto:

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

Quando pieghiamo verso il basso:

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

Regole della sfida:

• Puoi presumere che l'input avrà sempre almeno 1 carattere (che sarà anche l'output).
• Il formato di output è flessibile, quindi è possibile stampare su STDOUT o STDERR; ritorna come array stringa / elenco o carattere array 2D; stringa singola con new-line; eccetera.
• L'input conterrà solo caratteri alfanumerici ( a-zA-Z0-9)
• Puoi anche usare un carattere non alfanumerico per riempire gli spazi all'interno e / o attorno all'output di arte ASCII, come un punto ..
• Gli spazi finali e una singola nuova riga finale sono facoltativi.
• Continuiamo a svolgerci fino a quando il "blocco" esterno piegato non ha più centri da dispiegare.

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Le scappatoie predefinite sono vietate.
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se necessario.

Casi 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 byte

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

Provalo qui!

Questo si aspetta l'input nello stack, quindi per facilità d'uso ho aggiunto ,all'inizio. Ciò può causare problemi se l'input contiene solo numeri, quindi ecco una suite di test per questo.

√lH»{ā;l⁾:A∫Ba{bIwFIWhFbž;FIbI@ž}};}¹K⁴{ē2\⌡±e{@Κ};⁴┼┼};0E{ē2\⌡№:h++}╚Funzionano anche 70 byte , ma dato che solo ora ho implementato le √stringhe e la documentazione non ha menzionato che avrebbe una lunghezza minima, non la conto.

Spiegazione:

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

Carbone , 120 109 byte

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

Provalo online! Si noti che Ａda allora è stato modificato ≔e il collegamento riflette questo. Spiegazione:

       θ          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

Calcola h = int(sqrt(len(q))). ( Floordoveva ancora essere implementato ...)

Ｆη⊞υ✂θ×ιη

Estrae le hsezioni di lunghezza hdall'input. (In realtà non mi preoccupo di troncare le sezioni alla lunghezza h.) Uso un forloop piuttosto che un Mapperché ho bisogno Assigndel risultato di Mapqualche parte e questo non è banale quando ho a che fare con a Slice.

Ｆ⁴«

Lo svolgersi avviene 4 volte, una volta per ciascuna direzione (in basso, a destra, in alto, a sinistra come codificato). La variabile loop per questo loop è i.

   Ａυε

Prendi una copia della corda tagliata.

   Ｊ⁰¦⁰

Torna indietro all'origine della tela in modo che ogni hspiegazione inizi con il -by- hquadrato nello stesso posto.

   Ｆ÷⁺¹η²«

Ripetere i (h+1)/2tempi; una volta per ogni spiegazione, più una volta per il quadrato originale. La variabile loop per questo loop è k.

          Ｆ⁴«

Ripeti 4 volte, una volta per ogni lato del quadrato aperto. (Non uso la variabile loop l.)

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

Stampa un lato del quadrato aperto. Poiché questo è il kdispiegamento, il lato della piazza è h-2ke kallontana i personaggi dal bordo della piazza originale.

             ↷

Pivot pronto per stampare il lato successivo del quadrato.

               Ｅε       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

Ruota la stringa tagliata. (Sì, questo è un ξ. Non riesco ad usarlo spesso!) ＥηFunzionerebbe anche per l'esterno Map. La rotazione ha anche il comodo effetto collaterale di troncare la larghezza dell'array a h.

             ¶»

Dopo aver stampato il lato, il cursore si sposta dal bordo del quadrato. Stampare un personaggio in meno fallisce per i quadrati del lato 1 ed è comunque meno golfoso. Dopo aver ruotato in precedenza, la stampa di una nuova riga sposta comodamente il cursore sull'angolo.

            ﹪ι²         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

Capovolgi il quadrato verticalmente o orizzontalmente come appropriato.

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

Calcola lo spostamento verso il successivo spiegamento.

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

Spostati in senso orizzontale o verticale al successivo spiegamento, come appropriato.

Ecco un link alla versione a 97 byte ottenuta facendo uso di tutte le ultime funzionalità di Charcoal, tra cui Floor: Provalo online! Il collegamento è alla versione dettagliata del codice.