Bir kare dizge verildiğinde, dizgenin bütün çıkarımını, her açılma aşamasında dizge için üretin.

İp her seferinde çeyrek tur saat yönünde yırtılarak açılmalıdır.

Örnekler

Giriş :

A

Çıktı :

A

Not : Bu özel test durumu için kopyalanan girişi de ancak bayt sayınızı azaltmaya yardımcı olması durumunda kabul edeceğim .

Giriş :

DC
AB

Çıktı :

DC
AB

  D
ABC

ABCD

Giriş :

GFE
HID
ABC

Çıktı :

GFE
HID
ABC

   HG
   IF
ABCDE

     IH
ABCDEFG

       I
ABCDEFGH

ABCDEFGHI

Giriş :

JIHG
KPOF
LMNE
ABCD

Çıktı :

JIHG
KPOF
LMNE
ABCD

    LKJ
    MPI
    NOH
ABCDEFG

       NML
       OPK
ABCDEFGHIJ

          ON
          PM
ABCDEFGHIJKL

            PO
ABCDEFGHIJKLMN

              P
ABCDEFGHIJKLMNO

ABCDEFGHIJKLMNOP

kurallar

Bu kod-golf yani bayt cinsinden en kısa kod kazanır.

• Herhangi bir makul format, tutarlı olduğu varsayılarak G / Ç için kullanılabilir.
• Çıktının üst satırlarını doldurmak için boşluklar kullanılmalıdır.
• Yazdırılabilir tüm karakterlerin girişini işleyebilmelidir (boşluk dahil: \x20- \x7e):

 !.? "# $% & '() * +, - / 0123456789:; @ ABCDEFGHIJKLMNOPQRSTUVWXYZ [\] ^ _` abcdefghijklmnopqrstuvwxyz {|} ~

• Lider / takip eden boşluklara izin verilir.
• Dize her zaman bir kare olacağını varsayabilirsiniz.
• Tüm standart boşluklar yasaktır.

İlham: “Kontrol edilme” sayısını gösteren bir kare program yazın .

SOGL V0.12 , 21 20 19 18 17 bayt

ø;[;ο⁴№č▓┼№TJι;jI

Burada dene! ( →bu yığına girdi beklediği için eklendi)

Açıklama:

ø;[;ο⁴№č▓┼№TJι;jI
ø;               push an empty string below the input           stack with the input GFE,HID,ABC
  [              while [ToS (the array) isn't empty] do       ["", [["G","F","E"],["H","I","D"],["A","B","C"]]]  
                                                                stack at the second time looping
   ;               duplicate 2nd from top                     [[[H,G], [I,F], [D,E]], "ABC"]
    ο              wrap it in an array                        [[[H,G], [I,F], [D,E]], ["ABC"]]
     ⁴             duplicate 2nd from top                     [[[H,G], [I,F], [D,E]], ["ABC"], [[H,G], [I,F], [D,E]]]
      №            reverse vertically                         [[[H,G], [I,F], [D,E]], ["ABC"], [[D,E], [I,F], [H,G]]]
       č▓          join the inner arrays (┼ fails otherwise)  [[[H,G], [I,F], [D,E]], ["ABC"], ["DE", "IF", "HG"]]
         ┼         add the 2 parts together                   [[[H,G], [I,F], [D,E]], ["ABCDE", "   IF", "   HG"]]
          №        reverse vertically again                   [[[H,G], [I,F], [D,E]], ["   HG", "   IF", "ABCDE"]]
           T       print that without popping                 [[[H,G], [I,F], [D,E]], ["   HG", "   IF", "ABCDE"]]
            J      take the last line off                     [[[H,G], [I,F], [D,E]], ["   HG", "   IF"], "ABCDE"]
             ι     remove the rest of the array               [[[H,G], [I,F], [D,E]], "ABCDE"]
              ;j   remove the last line of the original array ["ABCDE", [[H,G], [I,F]]]
                I  rotate it clockwise                        ["ABCDE", [[I,H], [F,G]]]

Python 2 , 209 207 205 203 202 201 200 196 bayt

@Quelklef sayesinde -4 bayt !

s=input();l=len;k=''.join;exec"print s;s=[x for x in[' '*l(s[0])+k(x[:-1]for x in s[-2::-1])[t::l(s[0])-1]for t in range(l(s[0]))][:-1]+[s[-1]+k(x[-1]for x in s)[-2::-1]]if x.strip()];"*(2*l(s)-1)

Çevrimiçi deneyin!

Python 2 , 219 217 215 213 212 211 207 bayt

s=input();l=len;k=''.join;exec"print'\\n'.join(s);s=[x for x in[' '*l(s[0])+k(x[:-1]for x in s[-2::-1])[t::l(s[0])-1]for t in range(l(s[0]))][:-1]+[s[-1]+k(x[-1]for x in s)[-2::-1]]if x.strip()];"*(2*l(s)-1)

Çevrimiçi deneyin!

Bunlardan ilki bir Dizge listesi, ikincisi ASCII-art olarak çıkar.

Kömür , 42 35 bayt

ＡＥθＳθＷ⊟θ«⪫θ¶ＡＥι⮌⪫Ｅθ§μλωθ⊞υι↙←⮌⪫υωＤ⎚

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Düzenleme: Karakter dizilerinden dizgilere geçerek çoğunlukla 7 bayt kaydedildi. Açıklama:

ＡＥθＳθ

Girdi karesini değişkene dizge dizisi olarak okuyun q.

Ｗ⊟θ«

Dizideki son dize boş olmasa da kaldırın.

⪫θ¶

Dizinin geri kalanını yazdır.

ＡＥι⮌⪫Ｅθ§μλωθ

Son dizginin her bir karakterini dolaşarak ve lgeri kalan dizgede kalan her dizginin th karakterini birleştirerek dizinin geri kalanını döndürün .

⊞υι↙←⮌⪫υω

uKırılmamış değeri tutan önceden kaldırılmış son dizeyi ekleyip yazdırın.

Ｄ⎚

Sonucu çıktılayın ve bir sonraki yineleme için hazır olan tuvali temizleyin.

Unutmayın ki, bu sürüm 38 bayt için istenmiyorsa son dağıtmayı ayrı bir satıra çıkarır:

ＡＥθＳθＷ⊟θ«⊞υι←Ｅ⁺⟦⪫υω⟧⮌θ⮌κＡＥι⮌⪫Ｅθ§μλωθＤ⎚

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama: ←Ｅ⁺⟦⪫υω⟧⮌θ⮌κGeçerli diziyi ters çevirir, açılmamış çizgiyi hazırlar, sonra her satırdaki karakterleri ters çevirir, sonra her şeyi baş aşağı yazdırır, böylece istenen sonucu elde edilir.

Haskell , 127 120 bayt

e=[]:e
i#[x]=[]
i#s|t<-foldl(flip$zipWith(:))e$init s,j<-i++last s=(map((j>>" ")++)(init t)++[j++last t]):j#t
f s=s:""#s

Çevrimiçi deneyin!

Girdi örneğin, çizgiler listesidir ["DC","AB"]ikinci bir test durumu için, çıkış hatlarının listelerin bir listesi: [["DC","AB"],[" D","ABC"],["ABCD"]]. Sonucu mapM (putStrLn . unlines)güzel yazdırmak için kullanın .

Düzenleme: Bir yolculuk sırasında biraz kısatranspose bulduğumun, doğrudan aktarılan her birini tersine çevirmek için değiştirilebileceği için kısa bulduğumu fark ederek kaydedildi .

05AB1E , 18 bayt

[Dí.Bí»,¤UR¦ζŽ`Xì)

Çevrimiçi deneyin!

açıklama

[            Ž       # while stack is not empty, do:
 D                   # duplicate current list
  í                  # reverse each element
   .B                # pad with spaces to equal length
     í               # reverse each element again
      »,             # join with newlines and print
        ¤U           # store the last element in X
          R¦         # reverse the list and remove the first element
            ζ        # zip with spaces as filler
              `      # split elements separately to stack
               Xì    # prepend X to the last element
                 )   # join the stack to a list

J, 62 bayt

|."1@([:(#~[:-.[:*/"1' '=])|.@{:(}:@],{:@],[)|:@}:)^:(1<#)^:a:

Çevrimiçi deneyin!

Bunun çok fazla golf oynayabileceğine eminim. Bu, fazladan boşluklar yazdırır, ancak yalnızca J, çıktı dizisi içindeki dizileri aynı şekle sahip olacak şekilde biçimlendirdiğinden dolayı.

Sanırım bir kez girip tam olarak ne yaptığımı yorumladığımda, bunu nasıl golf oynayacağı konusunda daha iyi bir fikre sahip olabilirim (şimdi yaptım, gerçekten bilmiyorum ...). Golf amacıyla, bunu dikkate değer

• Özel durumlar için 1 satır girişi yapmam gerekiyor (döngünün parçası iken)
• Sadece boşluktan oluşan tüm çizgileri yok etmeliyim (elbette bunun için bir yerleşik olmalı ya da bunu yapmanın daha iyi bir yolu olmalı).
• Çok fazla büyük harf, özdeşlik işlevi ve üstünde

açıklama

Bunu çözerken ana işlevi üçe böldüm.

unfurl_reversed   =. |.@{: (}:@] , {:@] , [) |:@}:
whitespace_filter =. #~ [: -. [: */"1 ' ' = ]
unfurl            =. |."1@(whitespace_filter @: unfurl_reversed) ^: (1 < #) ^: a:

test_case         =. 3 3 $ 'GFEHIDABC'

İkinci test senaryosu ile çalışacağız.

unfurl_reversed

|.@{: (}:@] , {:@] , [) |:@}:

Bu bir dize bir kez açılmış, ancak ters yönde verir. Bunların hepsi tersten ve belirli bir sırada yapılıyor, böylece J, dizeleri otomatik olarak dizileri şekline uyacak şekilde boşluklarla otomatik olarak doldurur.

|:@}: Girişin kısıtlamasının devri

   |:@}: test_case
GH
FI
ED

|.@{: girişin kuyruğunun tersidir

   |.@{: test_case
CBA

Sanırım ne yapmak istediğimizi görebiliyorsunuz: kuyruğun tersini eğrinin devrik kısmının son kısmına eklemek istiyoruz (bu bir ağız doludur, fakat temel CBAolarak sonuna bağlanır ED). Bu, bize tersine dönmüş, bir parça çalkantı verecek.

(}:@],{:@],[) sadece bunu yapar.

Bu ekler CBAiçin ED, sonra dizinin geri kalanı ile bu katılır. Bu nedenle çıktılarımız

   unfurl_reversed test_case
GH   
FI   
EDCBA

whitespace_filter

#~ [: -. [: */"1 ' ' = ]
                 ' ' = ]  Equate each element to space
            */"1          Product of each row (all true?)
      -.                  Negate
#~                        Filter rows that are true

Temel olarak, bu, herhangi bir satırın tamamen boşluk olup olmadığını test eder ve öyleyse kaldırır. Test davasının ilk tekrarlaması için hiçbir şey yapmaz.

Bu gerekli (en azından bir alternatif bulana kadar) çünkü aksi halde sonuçta çıktı alanımızdaki boşlukları açacağız.

Unfurl

|."1@(whitespace_filter @: unfurl_reversed) ^: (1 < #) ^: a:

Unfurl temel olarak diğer fonksiyonları bir araya getirir ve özel durumlarda tek karakter girişleri yapar.

Fiil ( ^:) 'in gücüne boş kutu ( a:) verildiğinde, bir dizideki sonuçları birleştirip toplayana kadar bir girdiye bir işlev uygular.

(1 < #) satırların daima 1'den büyük olduğunu kontrol eder (özel durum 1 satır girişlerine).

|."1her satırı tersine çevirir, böylece sonuçlarını tersine çevirir whitespace_filter @: unfurl.

Python 2 , 143 132 bayt

a=input()
while 1:print'\n'.join(a);b=map(''.join,zip(*map(str.strip,a[-2::-1])));a[-1]+=b.pop();a[:-1]=[len(a[0])*' '+x for x in b]

Çevrimiçi deneyin!

Her bir yinelemede bdizesi “kafa” (birinci n-1 satır), 90 derece döndürülür: eğer abir [" NML", " OPK", "ABCDEFGHIJ"]daha sonra bbir["ON", "PM", "KL"] .

Bir zamanlar bir dize fora için, son satırı ekleyin büzere a[-1](vererek "ABCDEFGHIJKL") ve daha sonra yeniden hesaplamak a[:-1]dizeleri geri kalanında için boşluk ekleyerekb .

Boşken patlamaya çalışarak son bbuluruz.

Python 2,132 bayt

a=input()
while 1:s=str.strip;print'\n'.join(a);a[:-1]=[len(a[0])*' '+''.join(x)for x in zip(*map(s,a[-2::-1]))];a[-1]+=s(a.pop(-2))

Çevrimiçi deneyin!

Aynı fikir, farklı yazılmış. Sadece bir elementin a.pop(-2)ne zaman olduğuna teşebbüs ederek sonlandırıyoruz a.

Perl 5 , 155 bayt

$"=$,;@a=map[/./g],<>;while(@a){say' 'x(length$s)."@$_"for@a[0..@a-2];say$s.="@{pop@a}";say@b=();for$i(0..$#a){$q=0;$b[$q++][$#a-$i]=$_ for@{$a[$i]}}@a=@b}

Çevrimiçi deneyin!

Mantığı değiştirmeden birkaç bayt kaydedildi. Aşağıdaki akış hala temelde doğru.

# Perl 5 , 163 bayt

$"=$,;@a=map[/./g],<>;while(@a){say' 'x(length$s)."@{$a[$_]}"for 0..@a-2;say$s.="@{pop@a}";say@b=();for$i(0..$#a){$b[$_][$#a-$i]=$a[$i][$_]for 0..$#{$a[$i]}}@a=@b}

Çevrimiçi deneyin!

Nasıl?

$"=$,; #set the array output separator to null
@a=map[/./g],<>;   # take the input as a 2-D array @a
while(@a){         # repeat while there are still things to unfurl
  say' 'x(length$s)."@{$a[$_]}"for 0..@a-2; # output all but last
                                            # line of the remaining
                                            # square
  say$s.="@{pop@a}";  # remove bottom row, add it to the unfurled string $s
                      # and output it
  say@b=();           # clear temporary array; output empty array, causing
                      # a newline to output

                      # rotate remaining shape 90 degrees:
  for$i(0..$#a){$b[$_][$#a-$i]=$a[$i][$_]for 0..$#{$a[$i]}}
  @a=@b               # replace input with rotated array
}