Dada una cadena cuadrada, produce toda la salida para la cadena en cada etapa de despliegue.

La cuerda debe desplegarse en sentido horario un cuarto de vuelta a la vez.

Ejemplos

Entrada :

A

Salida :

A

Nota : También aceptaré la entrada duplicada para este caso de prueba en particular solo si esto ayuda a reducir el recuento de bytes.

Entrada :

DC
AB

Salida :

DC
AB

  D
ABC

ABCD

Entrada :

GFE
HID
ABC

Salida :

GFE
HID
ABC

   HG
   IF
ABCDE

     IH
ABCDEFG

       I
ABCDEFGH

ABCDEFGHI

Entrada :

JIHG
KPOF
LMNE
ABCD

Salida :

JIHG
KPOF
LMNE
ABCD

    LKJ
    MPI
    NOH
ABCDEFG

       NML
       OPK
ABCDEFGHIJ

          ON
          PM
ABCDEFGHIJKL

            PO
ABCDEFGHIJKLMN

              P
ABCDEFGHIJKLMNO

ABCDEFGHIJKLMNOP

Reglas

Este es el código de golf, por lo que gana el código más corto en bytes.

• Se puede usar cualquier formato razonable para E / S, suponiendo que sea coherente.
• Se deben usar espacios para rellenar las líneas superiores de la salida.
• Debe poder manejar la entrada de todos los caracteres imprimibles (incluido el espacio: \x20- \x7e):

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

• Se permite el espacio en blanco inicial / final.
• Puede suponer que la cadena siempre será un cuadrado.
• Todas las lagunas estándar están prohibidas.

Inspiración: escriba un programa cuadrado que genere la cantidad de veces que se ha "desenrollado" .

SOGL V0.12 , 21 20 19 18 17 bytes

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

Pruébalo aquí! ( →agregado porque esto espera entrada en la pila)

Explicación:

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

-4 bytes gracias 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)

Pruébalo en línea!

Python 2 , 219 217 215 213 212 211 207 bytes

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)

Pruébalo en línea!

El primero sale como una lista de cadenas, el segundo sale como ASCII-art.

Carbón , 42 35 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Editar: se guardaron 7 bytes principalmente al cambiar de matrices de caracteres a cadenas. Explicación:

ＡＥθＳθ

Lea el cuadrado de entrada como una matriz de cadenas en la variable q.

Ｗ⊟θ«

Mientras que la última cadena de la matriz no está vacía, quítela.

⪫θ¶

Imprime el resto de la matriz.

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

Gire el resto de la matriz al recorrer cada carácter de la última cadena y unir el lcarácter th de cada cadena restante en la matriz invertida.

⊞υι↙←⮌⪫υω

Agregue la última cadena eliminada anteriormente u, que contiene el valor desplegado, e imprímala.

Ｄ⎚

Imprima el resultado y luego limpie el lienzo listo para la próxima iteración.

Tenga en cuenta que esta versión genera el despliegue final en una línea separada, si esto no es deseable, entonces para 38 bytes:

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación: ←Ｅ⁺⟦⪫υω⟧⮌θ⮌κinvierte la matriz actual, antepone la línea desplegada, luego invierte los caracteres en cada línea, luego imprime todo al revés, produciendo así el resultado deseado.

Haskell , 127 120 bytes

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

Pruébalo en línea!

De entrada es una lista de líneas, por ejemplo, ["DC","AB"]para el segundo caso de prueba, la salida es una lista de listas de líneas: [["DC","AB"],[" D","ABC"],["ABCD"]]. Úselo mapM (putStrLn . unlines)para imprimir el resultado.

Editar: ahorré 7 bytes al notar que cuanto más cortotranspose encontré, mientras que un intento es útil porque se puede modificar para revertir cada transposición directamente.

05AB1E , 18 bytes

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

Pruébalo en línea!

Explicación

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

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

Pruébalo en línea!

Estoy seguro de que se puede jugar mucho al golf. Esto imprime espacios en blanco adicionales, pero solo por la forma en que J formatea las matrices contenidas dentro de la matriz de salida para que tengan la misma forma.

Creo que una vez que entre y comente exactamente lo que estoy haciendo, podría tener una mejor idea de cómo jugar golf (habiendo hecho eso ahora, realmente no sé ...). Para fines de golf, vale la pena señalar que

• Tengo un caso especial de entradas de 1 fila (la parte while del bucle)
• Tengo que eliminar todas las líneas que consisten únicamente en espacios en blanco (seguramente debe haber un incorporado para esto o una mejor manera de hacerlo), que es el filtro cerca del final
• Hay muchas mayúsculas, funciones de identidad y superiores

Explicación

Al desviar esto, dividiré la función principal en tres.

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

test_case         =. 3 3 $ 'GFEHIDABC'

Trabajaremos con el segundo caso de prueba.

unfurl_reversed

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

Esto le da a uno la cuerda desplegada una vez, pero a la inversa. Todo esto se está haciendo en reversa y en un orden específico para que la forma en que J rellena automáticamente las cadenas con espacios para que coincidan con la forma de la matriz en la que están dará el espacio correcto.

|:@}: es la transposición de la reducción de la entrada

   |:@}: test_case
GH
FI
ED

|.@{: es el reverso de la cola de la entrada

   |.@{: test_case
CBA

Creo que puedes ver lo que queremos hacer: queremos agregar el reverso de la cola a la última parte de la transposición de la cortina (eso es un bocado, pero básicamente se adjunta CBAal final de ED). Esto nos dará un paso de despliegue, invertido.

(}:@],{:@],[) hace exactamente eso

Se añade CBAa ED, a continuación, se une a que con el resto de la matriz. Nuestra salida por lo tanto es

   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

Básicamente, esto prueba para ver si alguna fila es completamente espacios, y la elimina si es así. No hace nada para la primera iteración del caso de prueba.

Esto es necesario (al menos hasta que encuentre una alternativa) ya que de lo contrario eventualmente desplegaremos espacios en blanco en nuestra cadena de salida.

desplegar

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

Unfurl básicamente pone las otras funciones juntas y casos especiales de entradas de un solo carácter.

Cuando al poder del verbo ( ^:) se le da el cuadro vacío ( a:), aplica una función en una entrada hasta que converge y recopila los resultados en una matriz.

(1 < #) comprueba que las filas son siempre mayores que 1 (para entradas de fila de caso especial 1).

|."1invierte cada fila, por lo que invierte los resultados de whitespace_filter @: unfurl.

Python 2 , 143 132 bytes

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]

Pruébalo en línea!

En cada iteración, bes la "cabeza" de la cadena (primeras n − 1 filas), girada 90 grados: si aes, [" NML", " OPK", "ABCDEFGHIJ"]entonces bes ["ON", "PM", "KL"].

Para desplegar una cadena una vez, agregamos la línea final de ba a[-1](dar "ABCDEFGHIJKL") y luego recalculamos a[:-1]agregando espacios al resto de las cadenas b.

Terminamos intentando saltar desde bcuando está vacío.

Python 2 , 132 bytes

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

Pruébalo en línea!

La misma idea, escrita de manera diferente. Terminamos intentando a.pop(-2)cuando asolo tiene un elemento.

Perl 5 , 155 bytes

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

Pruébalo en línea!

Guardado algunos bytes sin modificar realmente la lógica. El siguiente flujo sigue siendo básicamente correcto.

# Perl 5 , 163 bytes

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

Pruébalo en línea!

¿Cómo?

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