Le code de ce site s'épuise rapidement. Nous devons investir dans des chaînes renouvelables. Vous devez donc écrire un programme qui prend une chaîne et la convertit en moulin à vent.

Le défi

Prenons l'exemple d'une simple chaîne d'éoliennes. Prenez la ficelle abc. Le pivot est le caractère central, dans ce cas b. Étant donné que la chaîne est longue de 3 caractères, chaque sortie aura exactement trois lignes de haut et trois caractères de large. Voici votre sortie à l'étape 1. (Notez les espaces)

abc

Pour passer à l'étape suivante, faites pivoter chaque caractère autour du pivot dans le sens horaire. Voici l'étape 2:

une
 b
  c

Voici les étapes 3 à 8:

 une
 b
 c

  une
 b
c

cba

c
 b
  une

 c
 b
 une

  c
 b
une

Et à la neuvième étape, il fait le tour complet de la chaîne d'origine:

abc

Notez que le breste au même endroit tout le temps. C'est parce que bc'est le caractère pivot. Vous devez écrire un programme ou une fonction qui prend une chaîne en entrée et imprime à plusieurs reprises cette séquence jusqu'à la fermeture du programme.

Clarifications

• Toutes les chaînes d'entrée auront un nombre impair de caractères. (Pour que chaque moulin à vent ait un pivot)

• Pour garder le défi simple, toutes les chaînes ne contiendront que des caractères alphabétiques en majuscules et minuscules.

• La sortie doit être len(input_string)large et haute.

• Peu importe à quelle étape de la séquence vous commencez, tant que vous continuez à tourner et à boucler pour toujours.

Plus Test IO:

Puisque le message est déjà assez long, voici un lien vers la sortie pour "moulin à vent":

Sidenote:

Comme il s'agit d'un moulin à vent, ce serait génial si vous incluez du code passe-partout pour l'animer avec un petit délai ou une entrée utilisateur entre chaque étape. Cependant, comme certaines langues n'ont pas de temps intégré, ce n'est pas obligatoire. La partie concurrente de votre soumission peut simplement imprimer la séquence le plus rapidement possible.

MATL , 35 33 21 octets

jtn2/kYaG1$Xd`wtD3X!T

Ce qui suit animera le moulin à vent ( 26 octets )

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

Démo en ligne

Dans cette version, le Xxspécifie d'effacer l'affichage et le 1Y.est une pause de 1 seconde.

Explication

L'idée de base est que nous voulons créer deux versions de l'entrée. Une version "orthogonale"

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

Et une version "diagonale"

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

Nous poussons ces deux versions sur la pile. Chaque fois dans la boucle, nous changeons l'ordre de la pile et tournons celle du haut dans le sens des aiguilles d'une montre.

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 octets

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 octets

Code:

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

Essayez-le en ligne! . Assurez-vous d'appuyer sur le bouton kill juste après l'avoir exécuté, car il va dans une boucle infinie.

Rubis, 122 119 octets

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

Version non golfée avec sommeil, dans le programme de test

La rotation n'est pas très convaincante à pleine hauteur de console. Mais si vous réduisez la hauteur à la longueur de la chaîne d'entrée, la rotation est beaucoup plus convaincante.

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 octets

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

Essayez-le en ligne! (mais tuez-le immédiatement, boucle infinie)

Avec pause d'une seconde: 56 octets

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

Essayez-le en ligne! (encore une fois, boucle infinie)

Python 3 , 193 octets

def c (a): e = ''; s = len (a); l = int (s / 2); b = plage (s); m = '\ n' * l; print (m, a, m ); pour x en b: imprimer (e * x, a [x]); pour x en b: imprimer (e * l, a [x]); pour x en b: imprimer (e * (s-1- x), a [x]); a = input (); tandis que True: c (a); c (a [:: - 1]);

Non golfé

déf c (a):
    e = ''; s = len (a); l = int (s / 2); b = plage (s); m = '\ n' * l;
    impression (m, a, m);
    pour x en b: print (e * x, a [x]);
    pour x en b: print (e * l, a [x]);
    pour x en b: print (e * (s-1-x), a [x]); 
a = entrée ();
tandis que True:
    Californie);
    c (a [:: - 1]);

Récursif, 177 octets

(crash après quelques secondes)

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

Non golfé

déf c (a):
    e = ''; s = len (a); l = int (s / 2); b = plage (s); m = '\ n' * l;
    impression (m, a, m);
    pour x en b: print (e * x, a [x]);
    pour x en b: print (e * l, a [x]);
    pour x en b: print (e * (s-1-x), a [x]);
    c (a [:: - 1])
c (entrée ());

Une autre solution, 268 octets

importez itertools comme i; def w (a): e = ''; s = len (a); l = int (s / 2); t = '\ n'; m = (l-1) * t; h = liste (i.chain.from_iterable ((e * x + a [x], e * l + a [x], e * (s-1-x) + a [x]) pour x dans la plage (s) )); print (m, a, m, t.join (h [:: 3]), t.join (h [1 :: 3]), t.join (h [2 :: 3]), sep = t, end = ''); a = input (); tandis que True: w (a); w (a [:: - 1]);

Non golfé

importer itertools en tant que i;
def w (a):
    e = ''; s = len (a); l = int (s / 2); t = '\ n'; m = (l-1) * t;
    h = liste (i.chain.from_iterable ((e * x + a [x], e * l + a [x], e * (s-1-x) + a [x]) pour x dans la plage (s )))
    print (m, a, m, t.join (h [:: 3]), t.join (h [1 :: 3]), t.join (h [2 :: 3]), sep = t, end = '');
a = entrée ();
tandis que True:
    Washington);
    w (a [:: - 1]);

Pyth, 48 octets

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

Essayez-le en ligne! (Remarque: il s'agit d'une version qui ne boucle pas indéfiniment, car cela ferait planter l'interpréteur.)

Traduit sans vergogne de la solution Python 3 par @ByHH .

Comment ça fonctionne:

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