Data una stringa quadrata, produce tutto l'output per la stringa in ogni fase di dispiegamento.

La stringa deve svolgersi in senso orario di un quarto di giro alla volta.

Esempi

Input :

A

Uscita :

A

Nota : accetterò anche l'input duplicato per questo particolare test case solo se questo aiuta a ridurre il conteggio dei byte.

Input :

DC
AB

Uscita :

DC
AB

  D
ABC

ABCD

Input :

GFE
HID
ABC

Uscita :

GFE
HID
ABC

   HG
   IF
ABCDE

     IH
ABCDEFG

       I
ABCDEFGH

ABCDEFGHI

Input :

JIHG
KPOF
LMNE
ABCD

Uscita :

JIHG
KPOF
LMNE
ABCD

    LKJ
    MPI
    NOH
ABCDEFG

       NML
       OPK
ABCDEFGHIJ

          ON
          PM
ABCDEFGHIJKL

            PO
ABCDEFGHIJKLMN

              P
ABCDEFGHIJKLMNO

ABCDEFGHIJKLMNOP

Regole

Questo è code-golf quindi vince il codice più breve in byte.

• È possibile utilizzare qualsiasi formato ragionevole per l'I / O presupponendo che sia coerente.
• Gli spazi devono essere utilizzati per riempire le linee superiori dell'output.
• Deve essere in grado di gestire l'input di tutti i caratteri stampabili (incluso lo spazio: \x20- \x7e):

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

• Sono ammessi spazi iniziali / finali.
• Puoi presumere che la stringa sarà sempre un quadrato.
• Sono vietate tutte le scappatoie standard .

Ispirazione: Scrivi un programma quadrato che emetta il numero di volte che è stato "srotolato" .

SOGL V0.12 , 21 20 19 18 17 byte

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

Provalo qui! ( →aggiunto perché questo prevede input sullo stack)

Spiegazione:

ø;[;ο⁴№č▓┼№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 byte

-4 byte grazie a @Quelklef !

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)

Provalo online!

Python 2 , 219 217 215 213 212 211 207 byte

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)

Provalo online!

Il primo viene visualizzato come un elenco di stringhe, il secondo viene visualizzato come ASCII-art.

Carbone , 42 35 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Modifica: salvato 7 byte principalmente passando da array di caratteri a stringhe. Spiegazione:

ＡＥθＳθ

Leggi il quadrato di input come una matrice di stringhe nella variabile q.

Ｗ⊟θ«

Mentre l'ultima stringa nell'array non è vuota, rimuoverla.

⪫θ¶

Stampa il resto dell'array.

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

Ruota il resto dell'array eseguendo il ciclo attraverso ogni carattere dell'ultima stringa e unendo il lcarattere th di ogni stringa rimanente nell'array invertito.

⊞υι↙←⮌⪫υω

Aggiungi l'ultima stringa rimossa in precedenza u, che contiene il valore non spiegato e stampala.

Ｄ⎚

Stampa il risultato e quindi cancella la tela pronta per la prossima iterazione.

Si noti che questa versione genera il dispiegamento finale su una riga separata, se ciò non è desiderabile per 38 byte:

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione: ←Ｅ⁺⟦⪫υω⟧⮌θ⮌κinverte l'array corrente, antepone la riga spiegata, quindi inverte i caratteri in ciascuna riga, quindi stampa tutto sottosopra, producendo così il risultato desiderato.

Haskell , 127 120 byte

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

Provalo online!

Ingresso è una lista di linee, ad esempio ["DC","AB"]per il secondo caso di test, l'uscita è una lista di liste di linee: [["DC","AB"],[" D","ABC"],["ABCD"]]. Utilizzare mapM (putStrLn . unlines)per stampare graziosamente il risultato.

Modifica: salvato 7 byte notando che il più breve chetranspose ho trovato mentre un tentativo è utile perché può essere modificato per invertire ciascuno di essi direttamente trasposto.

05AB1E , 18 byte

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

Provalo online!

Spiegazione

[            Ž       # 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 byte

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

Provalo online!

Sono sicuro che questo può essere giocato molto a golf. Questo stampa spazi bianchi extra, ma solo a causa del modo in cui J formatta gli array contenuti nell'array di output per avere la stessa forma.

Penso che una volta entrato e commentando esattamente quello che sto facendo, potrei avere un'idea migliore di come giocare a golf (dopo averlo fatto ora, non lo so davvero ...). Ai fini del golf, vale la pena notare che

• Devo input per 1 riga caso speciale (la parte while del loop)
• Devo eliminare tutte le linee costituite esclusivamente da spazi bianchi (sicuramente ci deve essere un builtin per questo o un modo migliore per farlo), che è il filtro vicino alla fine
• Ci sono molti limiti, funzioni di identità e atops

Spiegazione

Nel disgregare questo, dividerò la funzione principale in tre.

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

test_case         =. 3 3 $ 'GFEHIDABC'

Lavoreremo con il secondo caso di test.

unfurl_reversed

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

Questo dà una stringa spiegata una volta, ma al contrario. Tutto questo viene fatto al contrario e in un ordine specifico in modo tale che il modo in cui J riempie automaticamente le stringhe con spazi per corrispondere alla forma dell'array in cui si trovano dia la giusta spaziatura.

|:@}: è la trasposizione della riduzione dell'ingresso

   |:@}: test_case
GH
FI
ED

|.@{: è il rovescio della coda dell'ingresso

   |.@{: test_case
CBA

Penso che tu possa vedere quello che vogliamo fare: vogliamo aggiungere il retro della coda all'ultima parte del trasposizione del ricciolo (è un boccone, ma fondamentalmente si attacca CBAalla fine di ED). Questo ci darà un passo di spiegamento, invertito.

(}:@],{:@],[) fa proprio questo.

Si aggiunge CBAa ED, quindi si unisce a quello con il resto dell'array. La nostra produzione quindi è

   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

Fondamentalmente, questo verifica se una riga è completamente spazio e la rimuove se lo è. Non fa nulla per la prima iterazione del test case.

Questo è necessario (almeno fino a quando non trovo un'alternativa) poiché altrimenti alla fine apriremo spazi bianchi nella nostra stringa di output.

spiegare

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

Unfurl fondamentalmente mette insieme le altre funzioni e casi speciali input di singoli caratteri.

Quando alla potenza di verb ( ^:) viene data la casella vuota ( a:), applica una funzione su un input fino a quando non converge e raccoglie i risultati in un array.

(1 < #) verifica che le righe siano sempre maggiori di 1 (per input di 1 riga caso speciale).

|."1inverte ogni riga, quindi inverte i risultati di whitespace_filter @: unfurl.

Python 2 , 143 132 byte

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]

Provalo online!

In ogni iterazione, bè la "testa" della stringa (prime n − 1 righe), ruotata di 90 gradi: se aè [" NML", " OPK", "ABCDEFGHIJ"]allora bè ["ON", "PM", "KL"].

Per srotolare una stringa una volta, aggiungiamo l'ultima riga di ba a[-1](dare "ABCDEFGHIJKL") e quindi ricalcolo a[:-1]aggiungendo spazi al resto delle stringhe in b.

Terminiamo tentando di saltar fuori da bquando è vuoto.

Python 2 , 132 byte

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

Provalo online!

Stessa idea, scritta diversamente. Terminiamo provando a a.pop(-2)quando aha un solo elemento.

Perl 5 , 155 byte

$"=$,;@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}

Provalo online!

Salvati pochi byte senza modificare realmente la logica. Il flusso di seguito è ancora sostanzialmente corretto.

# Perl 5 , 163 byte

$"=$,;@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}

Provalo online!

Come?

$"=$,; #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
}