Giriş:

Dizi

Çıktı:

Biz bir kare uzunluğunda bırakılır kadar 1) Öncelikle girdi-string sonunda kaldırma karakterini almak (yani 1, 4, 9, 16, 25, 36, vs.)
Yani abcdefghijklmnopqrstuvwxyz(uzunluk 26) olur abcdefghijklmnopqrstuvwxy( uzunluk 25).

2) Sonra bunu bir kerede bir satırda, soldan sağa koyarız:

abcde
fghij
klmno
pqrst
uvwxy

3) Bunu dört yönde de katlıyoruz (dış katlanmış 'blok' artık iç karakterleri kalmayıncaya kadar açılmaya devam ediyoruz):

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

Dikkat edilmesi gereken bazı şeyler, dışa doğru katlandığımızda, temelde bu şekilde yansırız (açıklama olarak eklenen sayılar, bu örneklerde 'dizinleri' temsil eder):

Sol tarafı katladığımızda:

 123    to:   321 123
fghij         ihgf   j

Sağ tarafı katladığımızda:

 123    to:    123 321
fghij         f   jihg

Yukarı doğru katlandığımızda:

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

Aşağı doğru katlandığımızda:

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

Zorluk kuralları:

• Girişin her zaman en az 1 karaktere sahip olacağını varsayabilirsiniz (bu da çıkış olacaktır).
• Çıktı formatı esnektir, böylece STDOUT veya STDERR'a yazdırabilirsiniz; dize dizisi / liste veya karakter 2D dizisi olarak dönme; yeni satırlı tek dize; vb.
• Giriş yalnızca alfasayısal karakterler içerecektir ( a-zA-Z0-9)
• ASCII-art çıktısının içindeki ve / veya çevresindeki boşlukları, nokta gibi doldurmak için alfasayısal olmayan bir karakter de kullanabilirsiniz ..
• Sondaki boşluklar ve tek bir sondaki yeni satır isteğe bağlıdır.
• Dış katlanmış 'blok' açılacak daha fazla merkez kalmayana kadar açılmaya devam ediyoruz.

Genel kurallar:

• Bu kod golf , bayt en kısa cevap kazanır.
  Kod golf dillerinin, kod yazmayan dillerle yanıt göndermenizi engellemesine izin vermeyin. 'Herhangi bir' programlama dili için mümkün olduğunca kısa bir cevap bulmaya çalışın.
• Cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT, fonksiyonlar / yöntem uygun parametreler ve dönüş tipi, tam programlar ile kullanılabilir. Çağrınız.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuz için test içeren bir bağlantı ekleyin.
• Ayrıca, gerekirse bir açıklama ekleyin.

Test senaryoları:

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 bayt

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

Buradan Deneyin!

Bu, yığındaki girişi bekler, bu nedenle kullanım kolaylığı ,için başlangıçta ekledim . Giriş yalnızca sayı içeriyorsa sorunlara neden olabilir, bu nedenle burada bir test takımı vardır.

70 bayt da √lH»{ā;l⁾:A∫Ba{bIwFIWhFbž;FIbI@ž}};}¹K⁴{ē2\⌡±e{@Κ};⁴┼┼};0E{ē2\⌡№:h++}╚çalışıyor, ancak şimdi sadece √dizelere uygulandığım ve belgelerin uzunluğunu katlayacağından bahsetmediğim için saymayacağım.

Açıklama:

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

Kömür , 120 109 bayt

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

Çevrimiçi deneyin! O Ａzamandan beri değiştirildiğini ≔ve bağlantının bunu yansıttığını unutmayın. Açıklama:

       θ          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

Hesaplar h = int(sqrt(len(q))). ( Floorhenüz uygulanmadı ...)

Ｆη⊞υ✂θ×ιη

Uzunluktaki hdilimleri hgirişten ayıklar . (Aslında dilimleri boyuna kısaltmak için zahmet etmiyorum h.) Bir fordöngü yerine bir döngü kullanıyorum Mapçünkü bir yerde Assignsonuca ihtiyacım var Mapve bu a ile uğraşırken önemsiz değil Slice.

Ｆ⁴«

Açılma 4 kez gerçekleşir, her yön için bir kez (aşağı, sağ, yukarı, kodlanmış olarak sola). Bu döngü için döngü değişkeni i.

   Ａυε

Dilimlenmiş dizenin bir kopyasını alın.

   Ｊ⁰¦⁰

Her bir hkatmanın haynı yerde -by- karesi ile başlaması için tuvalin kökenine geri atlayın .

   Ｆ÷⁺¹η²«

Tekrarlama (h+1)/2süreleri; her kat için bir kez, artı orijinal kare için bir kez. Bu döngü için döngü değişkeni k.

          Ｆ⁴«

Katlanmamış karenin her iki tarafı için 4 kez tekrarlayın. (Döngü değişkenini kullanmıyorum l.)

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

Katlanmamış karenin bir yüzünü yazdırın. Bu kaçılan olduğu için , kare tarafı h-2kve karakterleri korijinal karenin kenarından alır .

             ↷

Pivot, karenin bir sonraki yüzünü yazdırmaya hazır.

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

Dilimlenmiş dizgiyi döndürün. (Evet, bu bir ξ. Sık sık kullanmıyorum!) ＥηDış için de işe yarardı Map. Dönüş, dizinin genişliğini kısaltmanın kullanışlı yan etkisine de sahiptir h.

             ¶»

Tarafı yazdırdıktan sonra, imleç karenin kenarından çıkar. Bir karakterin daha az yazdırılması, 1. tarafın kareleri için başarısız oluyor ve yine de daha az golf oynuyor. Önceden döndürülmüş olan yeni satır yazdırmak, imleci rahatça köşeye taşır.

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

Kareyi uygun şekilde dikey veya yatay olarak çevirin.

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

Bir sonraki açılma için yer değiştirmeyi hesaplayın.

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

Yatay veya dikey olarak bir sonraki katına uygun şekilde ilerleyin.

İşte en son Kömür özelliklerinden yararlanarak elde edilen 97 baytlık sürüme bir bağlantı Floor: Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur.