O código neste site está sendo esgotado rapidamente. Precisamos investir em cadeias renováveis. Portanto, você deve escrever um programa que pegue uma string e a converta em um moinho de vento.

O desafio

Vamos dar um exemplo simples de um moinho de vento. Pegue a corda abc. O pivô é o caractere central, neste caso b. Como a string tem 3 caracteres, cada saída terá exatamente três linhas de altura e três caracteres de largura. Aqui está sua saída na etapa 1. (Observe o espaço em branco)

abc

Para obter o próximo passo, gire cada caractere ao redor do pivô no sentido horário. Aqui está o passo 2:

uma
 b
  c

Aqui estão as etapas 3 a 8:

 uma
 b
 c

  uma
 b
c

cba

c
 b
  uma

 c
 b
 uma

  c
 b
uma

E no nono passo, ele volta o círculo completo para a string original:

abc

Observe que o mesmo bpermaneceu no mesmo local o tempo todo. Isso ocorre porque bé o caractere dinâmico. Você deve escrever um programa ou função que use uma string como entrada e imprima repetidamente essa sequência até que o programa seja fechado.

Esclarecimentos

• Todas as seqüências de entrada terão um número ímpar de caracteres. (Para que todo moinho de vento tenha um pivô)

• Para manter o desafio simples, todas as cadeias conterão apenas caracteres alfabéticos maiúsculos e minúsculos.

• A saída deve ter len(input_string)caracteres largos e altos.

• Não importa em qual etapa da sequência você inicia, desde que continue girando e girando para sempre.

Mais IO de teste:

Como o post já é bastante longo, aqui está um link para a saída do "moinho de vento":

Nota:

Como esse é um moinho de vento, seria incrível se você incluísse algum código padrão para animá-lo com um pequeno atraso de tempo ou com uma entrada do usuário entre cada etapa. No entanto, como alguns idiomas não possuem tempo embutido, isso não é obrigatório. A parte concorrente do seu envio pode imprimir a sequência o mais rápido possível.

MATL , 35 33 21 bytes

jtn2/kYaG1$Xd`wtD3X!T

O seguinte animará o moinho de vento ( 26 bytes )

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

Demo Online

Nesta versão, o Xxespecificado para limpar a exibição e a 1Y.pausa de 1 segundo.

Explicação

A idéia básica é que queremos criar duas versões da entrada. Uma versão "ortogonal"

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

E uma versão "diagonal"

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

Colocamos essas duas versões na pilha. Cada vez no ciclo, alternamos a ordem da pilha e giramos a parte superior no sentido horário.

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

Experimente online! . Certifique-se de apertar o botão kill logo após executá-lo, porque ele entra em um loop infinito.

Ruby, 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}}

Versão ungolfed com sono, no programa de teste

A rotação não é muito convincente na altura total do console. Mas se você reduzir a altura ao comprimento da sequência de entrada, a rotação será muito mais 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

Experimente online! (mas mate-o imediatamente, loop infinito)

Com pausa de 1 segundo: 56 bytes

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

Experimente online! (novamente, loop infinito)

Python 3 , 193 bytes

() () () () () () () () () () () () (()) () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () (), () ); para x em b: imprimir (e * x, a [x]); para x em b: imprimir (e * l, a [x]); para x em b: imprimir (e * (s-1- x), a [x]); a = input (); enquanto True: c (a); c (a [:: - 1]);

Ungolfed

def c (a):
    e = ''; s = len (a); l = int (s / 2); b = intervalo (s); m = '\ n' * l;
    impressão (m, a, m);
    para x em b: print (e * x, a [x]);
    para x em b: print (e * l, a [x]);
    para x em b: print (e * (s-1-x), a [x]); 
a = entrada ();
enquanto True:
    c (a);
    c (a [:: - 1]);

Recursivo, 177 bytes

(falha após alguns segundos)

() () () () () () () () () () () () (()) () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () () (), () ); para x em b: imprimir (e * x, a [x]); para x em b: imprimir (e * l, a [x]); para x em b: imprimir (e * (s-1- x), a [x]); c (a [:: - 1]); c (entrada ());

Ungolfed

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

Outra solução, 268 bytes

Você pode usar o seguinte comando: \ ufffd \ ufffd \ ufffd \ ufffd \ ufffd \ ufffd \ ufffd \ ufffd \ ufffd \ ufffd \ ufffd \ ufffd = list (i.chain.from_iterable ((e * x + a [x], e * l + a [x], e * (s-1-x) + a [x]) para x no (s) intervalo (s) )); print (m, a, m, t.join (h [:: 3]), t.join (h [1 :: 3]), t.join (h [2 :: 3]), set = t, end = ''); a = input (); enquanto True: w (a); w (a [:: - 1]);

Ungolfed

importar instrumentos 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 no intervalo (s) )))
    print (m, a, m, t.join (h [:: 3]), t.join (h [1 :: 3]), t.join (h [2 :: 3]), sep = t, end = '');
a = entrada ();
enquanto True:
    w (a);
    w (a [:: - 1]);

Pitão, 48 bytes

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

Experimente online! (Nota: esta é uma versão que não se repete eternamente, porque poderia travar o intérprete.)

Traduzido descaradamente da solução Python 3 por @ByHH .

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