Il codice su questo sito si sta rapidamente esaurendo. Dobbiamo investire in stringhe rinnovabili. Quindi devi scrivere un programma che prende una stringa e la converte in un mulino a vento.

La sfida

Prendiamo ad esempio una semplice stringa da mulino a vento. Prendi la corda abc. Il perno è il personaggio centrale, in questo caso b. Poiché la stringa è lunga 3 caratteri, ogni output sarà esattamente alto tre righe e largo tre caratteri. Ecco il tuo output al passaggio 1. (Nota lo spazio bianco)

abc

Per ottenere il passaggio successivo, ruota ciascun personaggio attorno al perno in senso orario. Ecco il passaggio 2:

un'
 B
  c

Ecco i passaggi 3-8:

 un'
 B
 c

  un'
 B
c

cba

c
 B
  un'

 c
 B
 un'

  c
 B
un'

E al nono gradino, arriva attorno al cerchio completo della stringa originale:

abc

Si noti che è brimasto nello stesso posto per tutto il tempo. Questo perché bè il personaggio pivot. È necessario scrivere un programma o una funzione che accetta una stringa come input e stampa ripetutamente questa sequenza fino alla chiusura del programma.

chiarimenti

• Tutte le stringhe di input avranno un numero dispari di caratteri. (In modo che ogni mulino a vento avrà un perno)

• Per semplificare la sfida, tutte le stringhe conterranno solo caratteri alfabetici maiuscoli e minuscoli.

• L'output deve essere len(input_string)largo e largo.

• Non importa da quale fase della sequenza inizi, purché continui a ruotare e ad avvolgere per sempre.

Altro test IO:

Poiché il post è già piuttosto lungo, ecco un link all'output di "mulino a vento":

Nota a margine:

Dal momento che si suppone che questo sia un mulino a vento, sarebbe fantastico se includessi un codice di targa di caldaia per animarlo con un piccolo ritardo o un input dell'utente tra ogni passaggio. Tuttavia, poiché alcune lingue non dispongono di built-in per il tempo, questo non è obbligatorio. La parte concorrente dell'invio può semplicemente stampare la sequenza il più velocemente possibile.

MATL , 35 33 21 byte

jtn2/kYaG1$Xd`wtD3X!T

Quanto segue animerà il mulino a vento ( 26 byte )

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

Demo online

In questa versione, Xxspecifica di cancellare il display e 1Y.c'è una pausa di 1 secondo.

Spiegazione

L'idea di base è che vogliamo creare due versioni dell'input. Una versione "ortogonale"

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

E una versione "diagonale"

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

Inseriamo queste due versioni nello stack. Ogni volta attraverso il loop, cambiamo l'ordine di stack e ruotiamo quello superiore in senso orario.

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 byte

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 byte

Codice:

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

Provalo online! . Assicurati di premere il pulsante di interruzione subito dopo averlo eseguito, perché va in un ciclo infinito.

Rubino, 122 119 byte

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

Versione non golfata con sospensione, nel programma di test

La rotazione non è molto convincente a tutta altezza della console. Ma se riduci l'altezza alla lunghezza della stringa di input, la rotazione è molto più 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 byte

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

Provalo online! (ma uccidilo immediatamente, loop infinito)

Con pausa di 1 secondo: 56 byte

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

Provalo online! (di nuovo, loop infinito)

Python 3 , 193 byte

def c (a): e = ''; s = len (a); l = int (s / 2); b = range (s); m = '\ n' * l; print (m, a, m ); per x in b: stampa (e * x, a [x]); per x in b: stampa (e * l, a [x]); per x in b: stampa (e * (s-1- x), un [x]); a = input (); mentre True: c (a); c (a [:: - 1]);

Ungolfed

def c (a):
    e = ''; s = len (a); l = int (s / 2); b = range (s); m = '\ n' * l;
    stampare (m, a, m);
    per x in b: stampa (e * x, a [x]);
    per x in b: print (e * l, a [x]);
    per x in b: print (e * (s-1-x), a [x]); 
a = input ();
mentre vero:
    circa);
    c (un [:: - 1]);

Ricorsivo, 177 byte

(arresto anomalo dopo alcuni secondi)

def c (a): e = ''; s = len (a); l = int (s / 2); b = range (s); m = '\ n' * l; print (m, a, m ); per x in b: stampa (e * x, a [x]); per x in b: stampa (e * l, a [x]); per x in b: stampa (e * (s-1- x), un [x]), c (a [:: - 1]), c (input ());

Ungolfed

def c (a):
    e = ''; s = len (a); l = int (s / 2); b = range (s); m = '\ n' * l;
    stampare (m, a, m);
    per x in b: stampa (e * x, a [x]);
    per x in b: print (e * l, a [x]);
    per x in b: print (e * (s-1-x), a [x]);
    c (un [:: - 1])
c (input ());

Un'altra soluzione, 268 byte

import itertools as 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]) per x in range (s) )); stampa (m, a, m, t.join (h [:: 3]), t.join (h [1 :: 3]), t.join (h [2 :: 3]), settembre = t, end = ''); a = input (); mentre True: w (a); w (a [:: - 1]);

Ungolfed

import itertools as 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]) per x in range (s )))
    stampare (m, a, m, t.join (h [:: 3]), t.join (h [1 :: 3]), t.join (h [2 :: 3]), settembre = t, end = '');
a = input ();
mentre vero:
    w (a);
    w (un [:: - 1]);

Pyth, 48 byte

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

Provalo online! (Nota: questa è una versione che non esegue il ciclo per sempre, perché si bloccherebbe l'interprete.)

Spudoratamente tradotto dalla soluzione Python 3 di @ByHH .

Come funziona:

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