Der Code auf dieser Site wird schnell aufgebraucht. Wir müssen in erneuerbare Saiten investieren. Sie müssen also ein Programm schreiben, das einen String aufnimmt und in eine Windmühle umwandelt.

Die Herausforderung

Nehmen wir als Beispiel eine einfache Windmühlenschnur. Nimm die Schnur abc. In diesem Fall ist der Drehpunkt das zentrale Zeichen b. Da die Zeichenfolge 3 Zeichen lang ist, ist jede Ausgabe genau drei Zeilen groß und drei Zeichen breit. Hier ist Ihre Ausgabe in Schritt 1. (Beachten Sie das Leerzeichen)

ABC

Um den nächsten Schritt zu erreichen, drehen Sie jedes Zeichen im Uhrzeigersinn um den Drehpunkt. Hier ist Schritt 2:

ein
 b
  c

Hier sind die Schritte 3-8:

 ein
 b
 c

  ein
 b
c

cba

c
 b
  ein

 c
 b
 ein

  c
 b
ein

Beim neunten Schritt schließt sich der Kreis zur ursprünglichen Zeichenfolge:

ABC

Beachten Sie, dass bdie ganze Zeit an der gleichen Stelle geblieben ist. Dies liegt daran, dass bes sich um das Pivot-Zeichen handelt. Sie müssen ein Programm oder eine Funktion schreiben, die eine Zeichenfolge als Eingabe verwendet und diese Sequenz wiederholt ausgibt, bis das Programm geschlossen wird.

Klarstellungen

• Alle eingegebenen Zeichenfolgen haben eine ungerade Anzahl von Zeichen. (Damit jede Windmühle einen Drehpunkt hat)

• Um die Herausforderung einfach zu halten, enthalten alle Zeichenfolgen nur Groß- und Kleinbuchstaben.

• Die Ausgabe muss len(input_string)Zeichen breit und hoch sein.

• Es spielt keine Rolle, mit welchem ​​Schritt der Sequenz Sie beginnen, solange Sie sich weiter drehen und für immer eine Schleife bilden.

Mehr Test IO:

Da der Beitrag schon ziemlich lang ist, hier ein Link zur Ausgabe für "windmill":

Randnotiz:

Da dies eine Windmühle sein soll, wäre es fantastisch, wenn Sie einen Boilerplate-Code einfügen, um ihn mit einer kleinen Zeitverzögerung oder einer Benutzereingabe zwischen den einzelnen Schritten zu animieren. Da einige Sprachen jedoch keine integrierten Zeitfunktionen haben, ist dies nicht zwingend erforderlich. Der konkurrierende Teil Ihrer Einreichung kann die Sequenz einfach so schnell wie möglich ausdrucken.

MATL , 35 33 21 Bytes

jtn2/kYaG1$Xd`wtD3X!T

Im Folgenden wird die Windmühle animiert ( 26 Byte) )

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

Online Demo

In dieser Version ist die Xx gibt das an, dass die Anzeige gelöscht werden soll, und es 1Y.erfolgt eine Pause von 1 Sekunde.

Erläuterung

Die Grundidee ist, dass wir zwei Versionen der Eingabe erstellen möchten. Eine "orthogonale" Version

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

Und eine "diagonale" Version

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

Wir schieben diese beiden Versionen auf den Stapel. Jedes Mal, wenn wir die Schleife durchlaufen, wechseln wir die Stapelreihenfolge und drehen die obere im Uhrzeigersinn.

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 Bytes

Code:

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

Probieren Sie es online! . Stellen Sie sicher, dass Sie die Kill-Taste direkt nach dem Ausführen drücken, da sie in eine Endlosschleife übergeht.

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

Ungolfed-Version mit Schlaf, im Testprogramm

Die Rotation ist bei voller Konsolenhöhe nicht sehr überzeugend. Wenn Sie jedoch die Höhe auf die Länge der Eingabezeichenfolge reduzieren, ist die Drehung viel überzeugender.

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

Probieren Sie es online! (aber sofort töten, Endlosschleife)

Mit 1-Sekunden-Pause: 56 Bytes

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

Probieren Sie es online! (wieder Endlosschleife)

Python 3 , 193 Bytes

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

Ungolfed

def c (a):
    e = ''; s = len (a); l = int (s / 2); b = range (s); m = '\ n' * l;
    print (m, a, m);
    für x in b: print (e * x, a [x]);
    für x in b: print (e * l, a [x]);
    für x in b: print (e * (s-1-x), a [x]); 
a = input ();
während wahr:
    c (a);
    c (a [:: - 1]);

Rekursiv, 177 Bytes

(Absturz nach wenigen Sekunden)

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

Ungolfed

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

Eine andere Lösung, 268 Bytes

Importiere itertools als 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]) für x in Bereich (en) )); 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]);

Ungolfed

importiere itertools als 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]) für x in range (s )))
    print (m, a, m, t.join (h [:: 3]), t.join (h [1 :: 3]), t.join (h [2 :: 3]), sep = t, Ende = '');
a = input ();
während wahr:
    w (a);
    w (a [:: - 1]);

Pyth, 48 Bytes

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

Probieren Sie es online! (Hinweis: Dies ist eine Version, die keine Endlosschleife ausführt, da der Interpreter abstürzen würde.)

Schamlos übersetzt aus der Python 3-Lösung von @ByHH .

Wie es funktioniert:

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