Étant donné une chaîne carrée, produisez toutes les sorties de la chaîne à chaque étape du déroulement.

La chaîne doit se dérouler dans le sens horaire un quart de tour à la fois.

Exemples

Entrée :

A

Sortie :

A

Remarque : J'accepte également l'entrée dupliquée pour ce cas de test particulier uniquement si cela permet de réduire le nombre d'octets.

Entrée :

DC
AB

Sortie :

DC
AB

  D
ABC

ABCD

Entrée :

GFE
HID
ABC

Sortie :

GFE
HID
ABC

   HG
   IF
ABCDE

     IH
ABCDEFG

       I
ABCDEFGH

ABCDEFGHI

Entrée :

JIHG
KPOF
LMNE
ABCD

Sortie :

JIHG
KPOF
LMNE
ABCD

    LKJ
    MPI
    NOH
ABCDEFG

       NML
       OPK
ABCDEFGHIJ

          ON
          PM
ABCDEFGHIJKL

            PO
ABCDEFGHIJKLMN

              P
ABCDEFGHIJKLMNO

ABCDEFGHIJKLMNOP

Règles

Il s'agit de code-golf, donc le code le plus court en octets l'emporte.

• Tout format raisonnable peut être utilisé pour les E / S en supposant qu'il soit cohérent.
• Des espaces doivent être utilisés pour remplir les lignes supérieures de la sortie.
• Doit être capable de gérer la saisie de tous les caractères imprimables (y compris l'espace: \x20- \x7e):

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

• Les espaces blancs avant / arrière sont autorisés.
• Vous pouvez supposer que la chaîne sera toujours un carré.
• Toutes les failles standard sont interdites.

Inspiration: Écrivez un programme carré qui affiche le nombre de fois qu'il a été «déroulé» .

SOGL V0.12 , 21 20 19 18 17 octets

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

Essayez-le ici! ( →ajouté car cela attend une entrée sur la pile)

Explication:

ø;[;ο⁴№č▓┼№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 203 202 201 200 196 octets

-4 octets grâce à @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)

Essayez-le en ligne!

Python 2 , 219 217 215 213 212 212 211 207 octets

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)

Essayez-le en ligne!

Le premier sort sous forme de liste de chaînes, le second sort sous forme ASCII.

Fusain , 42 35 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Edit: 7 octets enregistrés principalement en passant des tableaux de caractères aux chaînes. Explication:

ＡＥθＳθ

Lisez le carré d'entrée comme un tableau de chaînes dans la variable q.

Ｗ⊟θ«

Alors que la dernière chaîne du tableau n'est pas vide, supprimez-la.

⪫θ¶

Imprimez le reste du tableau.

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

Faites pivoter le reste du tableau en parcourant chaque caractère de la dernière chaîne et en joignant le le caractère de chaque chaîne restante du tableau inversé.

⊞υι↙←⮌⪫υω

Ajoutez la dernière chaîne précédemment supprimée à u, qui contient la valeur déployée, et imprimez-la.

Ｄ⎚

Générez le résultat, puis effacez le canevas prêt pour la prochaine itération.

Notez que cette version affiche le déroulement final sur une ligne distincte, si cela n'est pas souhaitable, alors pour 38 octets:

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication: ←Ｅ⁺⟦⪫υω⟧⮌θ⮌κinverse le tableau actuel, ajoute la ligne déployée, inverse les caractères de chaque ligne, puis imprime tout à l'envers, produisant ainsi le résultat souhaité.

Haskell , 127 120 octets

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

Essayez-le en ligne!

L' entrée est une liste de lignes, par exemple ["DC","AB"]pour le second scénario de test, la sortie est une liste de listes de lignes: [["DC","AB"],[" D","ABC"],["ABCD"]]. Utilisez mapM (putStrLn . unlines)pour imprimer le résultat.

Edit: économisé 7 octets en notant que le plus courttranspose j'en ai trouvé pendant qu'un go est pratique car il peut être modifié pour inverser directement chaque transposé.

05AB1E , 18 octets

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

Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne!

Je suis sûr que cela peut être joué beaucoup. Cela imprime des espaces supplémentaires, mais uniquement en raison de la façon dont J met en forme les tableaux contenus dans le tableau en sortie pour qu'ils aient la même forme.

Je pense qu'une fois que j'entrerai et commenterai exactement ce que je fais, je pourrais avoir une meilleure idée de comment jouer au golf (après l'avoir fait maintenant, je ne sais pas vraiment ...). Aux fins du golf, il convient de noter que

• Je dois faire des entrées spéciales sur une ligne (la partie while de la boucle)
• Je dois éliminer toutes les lignes constituées uniquement d'espaces (il doit sûrement y avoir soit une fonction intégrée pour cela, soit une meilleure façon de le faire), qui est le filtre près de la fin
• Il y a beaucoup de casquettes, de fonctions d'identité et de sommets

Explication

En dégoûtant cela, je diviserai la fonction principale en trois.

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

test_case         =. 3 3 $ 'GFEHIDABC'

Nous allons travailler avec le deuxième cas de test.

unfurl_reversed

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

Cela donne une chaîne déroulée une fois, mais en sens inverse. Tout cela se fait en sens inverse et dans un ordre spécifique afin que la façon dont J remplit automatiquement les chaînes avec des espaces pour correspondre à la forme du tableau dans lequel elles se trouvent donnera le bon espacement.

|:@}: est la transposition de la restriction de l'entrée

   |:@}: test_case
GH
FI
ED

|.@{: est l'inverse de la queue de l'entrée

   |.@{: test_case
CBA

Je pense que vous pouvez voir ce que nous voulons faire: nous voulons ajouter le revers de la queue à la dernière partie de la transposition de la queue (c'est une bouchée, mais essentiellement attacher CBAà la fin de ED). Cela nous donnera une étape de déploiement, inversée.

(}:@],{:@],[) fait juste cela.

Il s'ajoute CBAà ED, puis rejoint cela avec le reste du tableau. Notre production est donc

   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

Fondamentalement, cela teste pour voir si une ligne est complètement vide et la supprime si elle l'est. Il ne fait rien pour la première itération du cas de test.

C'est nécessaire (au moins jusqu'à ce que je trouve une alternative) car sinon, nous finirons par déployer des espaces dans notre chaîne de sortie.

déployer

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

Unfurl rassemble essentiellement les autres fonctions et les cas spéciaux à un seul caractère.

Lorsque la puissance de verb ( ^:) est donnée à la case vide ( a:), elle applique une fonction sur une entrée jusqu'à ce qu'elle converge et recueille les résultats dans un tableau.

(1 < #) vérifie que les lignes sont toujours supérieures à 1 (dans le cas spécial 1 entrée de ligne).

|."1inverse chaque ligne, donc il inverse les résultats de whitespace_filter @: unfurl.

Python 2 , 143 132 octets

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]

Essayez-le en ligne!

Dans chaque itération, best la «tête» de la chaîne (premières n − 1 lignes), tournée de 90 degrés: si aest [" NML", " OPK", "ABCDEFGHIJ"]alors best ["ON", "PM", "KL"].

Pour dérouler une chaîne une fois, nous ajoutons la dernière ligne de bà a[-1](donnant "ABCDEFGHIJKL"), puis recalculons a[:-1]en ajoutant des espaces au reste des chaînes dans b.

Nous terminons en essayant de sortir de bquand il est vide.

Python 2 , 132 octets

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

Essayez-le en ligne!

Même idée, écrite différemment. Nous terminons en essayant de a.pop(-2)quand an'a qu'un seul élément.

Perl 5 , 155 octets

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

Essayez-le en ligne!

Enregistré quelques octets sans vraiment modifier la logique. Le flux ci-dessous est toujours fondamentalement correct.

# Perl 5 , 163 octets

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

Essayez-le en ligne!

Comment?

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