El código en este sitio se está agotando rápidamente. Necesitamos invertir en cadenas renovables. Por lo tanto, debe escribir un programa que tome una cadena y la convierta en un molino de viento.

El reto

Tomemos una simple cadena de molino de viento como ejemplo. Toma la cuerda abc. El pivote es el carácter central, en este caso b. Como la cadena tiene 3 caracteres de longitud, cada salida tendrá exactamente tres líneas de alto y tres caracteres de ancho. Aquí está su salida en el paso 1. (Tenga en cuenta el espacio en blanco)

a B C

Para obtener el siguiente paso, gire cada personaje alrededor del pivote en el sentido de las agujas del reloj. Aquí está el paso 2:

un
 si
  C

Aquí están los pasos 3-8:

 un
 si
 C

  un
 si
C

cba

C
 si
  un

 C
 si
 un

  C
 si
un

Y en el noveno paso, se completa el círculo hasta la cadena original:

a B C

Tenga en cuenta que bpermanecieron en el mismo lugar todo el tiempo. Esto se debe a que bes el carácter pivote. Debe escribir un programa o función que tome una cadena como entrada e imprima repetidamente esta secuencia hasta que se cierre el programa.

Aclaraciones

• Todas las cadenas de entrada tendrán un número impar de caracteres. (Para que cada molino de viento tenga un pivote)

• Para mantener el desafío simple, todas las cadenas solo contendrán caracteres del alfabeto en mayúsculas y minúsculas.

• La salida debe ser len(input_string)caracteres anchos y altos.

• No importa en qué paso de la secuencia comience, siempre y cuando continúe girando y dando vueltas para siempre.

Más prueba IO:

Como la publicación ya es bastante larga, aquí hay un enlace a la salida de "windmill":

Nota al margen:

Como se supone que es un molino de viento, sería increíble si incluye algún código repetitivo para animarlo con un pequeño retraso de tiempo o una entrada del usuario entre cada paso. Sin embargo, dado que algunos idiomas no tienen tiempo incorporado, esto no es obligatorio. La parte competitiva de su envío puede imprimir la secuencia lo más rápido posible.

MATL , 35 33 21 bytes

jtn2/kYaG1$Xd`wtD3X!T

Lo siguiente animará el molino de viento ( 26 bytes )

jtn2/kYaG1$Xd`wtXxDlY.3X!T

Demo en línea

En esta versión, el Xxespecifica para borrar la pantalla y 1Y.es una pausa de 1 segundo.

Explicación

La idea básica es que queremos crear dos versiones de la entrada. Una versión "ortogonal"

+-----+
|     |       
|     |
|abcde|
|     |
|     |
+-----+

Y una versión "diagonal"

+-----+
|a    |
| b   |
|  c  |
|   d |
|    e|
+-----+

Empujamos estas dos versiones a la pila. Cada vez a través del bucle, cambiamos el orden de la pila y giramos el superior en el sentido de las agujas del reloj.

j       % Grab the input as a string
t       % Duplicate the input

%--- Create the "orthogonal" version ---%

n2/     % Determine numel(input) / 2
k       % Round down to nearest integer
Ya      % Pad the input string with floor(numel(input)/2) rows above and below 

%--- Create the "diagonal" version ---%

G       % Grab the input again
1$Xd    % Place the input along the diagonal of a matrix    

`       % do...while loop   
  w     % Flip the order of the first two elements on the stack
  t     % Duplicate the top of the stack

  %--- OCTAVE ONLY (converts NULL to space chars) ---%

  O       % Create a scalar zero
  32      % Number literal (ASCII code for ' ')
  XE      % Replaces 0 elements in our 3D array with 32 (' ')

  %--- END OCTAVE ONLY ---%

  D     % Display the element     
  3X!   % Rotate this element 90 degrees counter-clockwise 3 times (clockwise)
  T     % Explicit TRUE to create an infinite loop
        % Implicit end of while loop

JavaScript (ES6), 291 bytes

r=a=>{w.textContent=a.map(a=>a.join``).join`
`;for(i=j=h=a.length>>1;j++,i--;){t=a[i][i];a[i][i]=a[h][i];a[h][i]=a[j][i];a[j][i]=a[j][h];a[j][h]=a[j][j];a[j][j]=a[h][j];a[h][j]=a[i][j];a[i][j]=a[i][h];a[i][h]=t}}
s=w=>{a=[...w=[...w]].map(_=>w.map(_=>' '));a[w.length>>1]=w;setInterval(r,1000,a)}
s("windmills")

<pre id=w>

05AB1E , 88 53 bytes

Código:

¹VYg;ïU[2FX¶×DYsJ,YvNð×y¶J?}YvðX×yJ,}Yv¹gN>-ð×yJ,}YRV

Pruébalo en línea! . Asegúrese de presionar el botón de matar justo después de ejecutarlo, ya que entra en un bucle infinito.

Rubí, 122 119 bytes

->n{c=0
loop{i=[l=n.size,m=l+1,m+1,1][3-c=c+1&7]*(3.5<=>c)
s=(' '*l+$/)*l
l.times{|j|s[m*l/2-1+(j-l/2)*i]=n[j]}
$><<s}}

Versión sin golf con suspensión, en programa de prueba

La rotación no es muy convincente a la altura total de la consola. Pero si reduce la altura a la longitud de la cadena de entrada, la rotación es mucho más convincente.

f=->n{
  c=0                                     #loop counter
  m=1+l=n.size                            #l=string length. m=l+1
  loop{                                   #start infinite loop
    s=(' '*l+$/)*l                        #make a string of l newline-terminated lines of l spaces. Total m characters per line.              
    i=[m-1,m,m+1,1][3-c=c+1&7]*(3.5<=>c)  #array contains positive distance between characters in string 1=horizontal, m=vertical, etc.
                                          #c=c+1&7 cycles through 0..7. Array index 3..-4 (negative indices count from end of array, so 3=-1, 0=-4 etc)
                                          #(3.5<=>c) = 1 or -1. We use to flip the sign. This is shorter than simply using 8 element array [m-1,m,m+1,1,1-m,-m,-m+1,-1]  
    l.times{|j|s[m*l/2-1+i*(j-l/2)]=n[j]} #for each character in n, write the appropriate space character in s to the character in n
    puts s                                #print s
    sleep 1                               #sleep for 1 second
  }
}

f[gets.chomp]                             #get input, remove newline, call function

MATL , 47 44 bytes

' 'jntX"tGtnXyg(wGtnQ2/Y(XJDXKD`J@_X!DK3X!DT

Pruébalo en línea!(pero mátalo inmediatamente, bucle infinito)

Con pausa de 1 segundo: 56 bytes

' 'jntX"tGtnXyg(wGtnQ2/Y(XJD1Y.XKD1Y.`J@_X!D1Y.K3X!D1Y.T

Pruébalo en línea! (de nuevo, bucle infinito)

Python 3 , 193 bytes

def c (a): e = ''; s = len (a); l = int (s / 2); b = rango (s); m = '\ n' * l; print (m, a, m ); para x en b: print (e * x, a [x]); para x en b: print (e * l, a [x]); para x en b: print (e * (s-1- x), a [x]); a = input (); while True: c (a); c (a [:: - 1]);

Sin golf

def c (a):
    e = ''; s = len (a); l = int (s / 2); b = rango (s); m = '\ n' * l;
    imprimir (m, a, m);
    para x en b: print (e * x, a [x]);
    para x en b: print (e * l, a [x]);
    para x en b: print (e * (s-1-x), a [x]); 
a = input ();
mientras cierto:
    California);
    c (a [:: - 1]);

Recursivo, 177 bytes

(choque después de unos segundos)

def c (a): e = ''; s = len (a); l = int (s / 2); b = rango (s); m = '\ n' * l; print (m, a, m ); para x en b: print (e * x, a [x]); para x en b: print (e * l, a [x]); para x en b: print (e * (s-1- x), a [x]); c (a [:: - 1]); c (input ());

Sin golf

def c (a):
    e = ''; s = len (a); l = int (s / 2); b = rango (s); m = '\ n' * l;
    imprimir (m, a, m);
    para x en b: print (e * x, a [x]);
    para x en b: print (e * l, a [x]);
    para x en b: print (e * (s-1-x), a [x]);
    c (a [:: - 1])
c (entrada ());

Otra solución, 268 bytes.

importar itertools como i; def w (a): e = ''; s = len (a); l = int (s / 2); t = '\ n'; m = (l-1) * t; h = lista (i.chain.from_iterable ((e * x + a [x], e * l + a [x], e * (s-1-x) + a [x]) para x en rango (s) )); print (m, a, m, t.join (h [:: 3]), t.join (h [1 :: 3]), t.join (h [2 :: 3]), sep = t, end = ''); a = input (); while True: w (a); w (a [:: - 1]);

Sin golf

importar itertools como i;
def w (a):
    e = ''; s = len (a); l = int (s / 2); t = '\ n'; m = (l-1) * t;
    h = list (i.chain.from_iterable ((e * x + a [x], e * l + a [x], e * (s-1-x) + a [x]) para x en el rango (s )))
    print (m, a, m, t.join (h [:: 3]), t.join (h [1 :: 3]), t.join (h [2 :: 3]), sep = t, fin = '');
a = input ();
mientras cierto:
    Washington);
    w (a [:: - 1]);

Pyth, 48 bytes

JlzK/J2#*btKz*btKM+*dG@zHVJgNN)VJgKN)VJg-JNN)=_z

Pruébalo en línea! (Nota: esta es una versión que no se repite para siempre, ya que bloquearía el intérprete).

Traducido descaradamente de la solución Python 3 por @ByHH .

Cómo funciona:

JlzK/J2#*btKz*btKM+*dG@zHVJgNN)VJgKN)VJg-JNN)=_z
                                                 assign('z',input())
Jlz                                              assign("J",Plen(z))
   K/J2                                          assign("K",div(J,2))
       #                                         loop-until-error:
        *btK                                      imp_print(times(b,tail(K)))
            z                                     imp_print(z)
             *btK                                 imp_print(times(b,tail(K)))
                                                  @memoized
                 M                                def gte(G,H):
                  +*dG@zH                          return plus(times(d,G),lookup(z,H))
                         VJ   )                   for N in num_to_range(J):
                           gNN                     imp_print(gte(N,N))
                               VJ   )             for N in num_to_range(J):
                                 gKN               imp_print(gte(K,N))
                                     VJ     )     for N in num_to_range(J):
                                       g-JNN       imp_print(gte(minus(J,N),N))
                                             =_z  assign('z',neg(z))