Kod na tej stronie szybko się wyczerpuje. Musimy inwestować w łańcuchy odnawialne. Musisz napisać program, który pobiera ciąg znaków i przekształca go w wiatrak.

Wyzwanie

Jako przykład weźmy prosty ciąg wiatraka. Weź sznurek abc. W tym przypadku oś jest postacią centralną b. Ponieważ łańcuch ma długość 3 znaków, każde wyjście będzie miało dokładnie trzy linie wysokości i trzy znaki szerokości. Oto Twój wynik z kroku 1. (Zwróć uwagę na białe znaki)

ABC

Aby przejść do następnego kroku, obróć każdą postać wokół osi obrotu w prawo. Oto krok 2:

za
 b
  do

Oto kroki 3-8:

 za
 b
 do

  za
 b
do

cba

do
 b
  za

 do
 b
 za

  do
 b
za

I na dziewiątym kroku, zatacza pełne koło oryginalnego łańcucha:

ABC

Zauważ, że bcały czas przebywałem w tym samym miejscu. Jest tak, ponieważ bjest to znak przestawny. Musisz napisać program lub funkcję, która pobiera ciąg znaków jako dane wejściowe i wielokrotnie drukuje tę sekwencję, aż program zostanie zamknięty.

Wyjaśnienia

• Wszystkie ciągi wejściowe będą miały nieparzystą liczbę znaków. (Aby każdy wiatrak miał oś obrotu)

• Aby zadanie było proste, wszystkie ciągi znaków będą zawierały tylko wielkie i małe litery alfabetu.

• Dane wyjściowe muszą być len(input_string)szerokie i wysokie.

• Nie ma znaczenia, od którego etapu sekwencji zaczniesz, tak długo, jak będziesz kontynuować obracanie i zapętlanie na zawsze.

Więcej testów IO:

Ponieważ post jest już dość długi, oto link do wyjścia dla „wiatraka”:

Dygresja:

Ponieważ ma to być wiatrak, byłoby wspaniale, gdybyś umieścił jakiś kod bojlera, aby go animować z małym opóźnieniem czasowym lub wkładem użytkownika między każdym krokiem. Ponieważ jednak niektóre języki nie mają wbudowanych funkcji czasu, nie jest to obowiązkowe. Konkurująca część Twojego zgłoszenia może po prostu wydrukować sekwencję tak szybko, jak to możliwe.

MATL , 35 33 21 bajtów

jtn2/kYaG1$Xd`wtD3X!T

Poniższe animuje wiatrak ( 26 bajtów )

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

Demo online

W tej wersji Xxspecyfikacja kasuje wyświetlacz i 1Y.jest to 1-sekundowa pauza.

Wyjaśnienie

Podstawową ideą jest to, że chcemy stworzyć dwie wersje danych wejściowych. Wersja „ortogonalna”

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

I wersja „diagonalna”

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

Wypychamy te dwie wersje na stos. Za każdym razem przez pętlę zmieniamy kolejność stosów i obracamy górną zgodnie z ruchem wskazówek zegara.

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 bajtów

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 bajtów

Kod:

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

Wypróbuj online! . Pamiętaj, aby nacisnąć przycisk zabicia zaraz po uruchomieniu, ponieważ przechodzi on w nieskończoną pętlę.

Ruby, 122 119 bajtów

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

Wersja bez golfa ze snem, w programie testowym

Obrót nie jest zbyt przekonujący na pełnej wysokości konsoli. Ale jeśli zmniejszysz wysokość do długości ciągu wejściowego, obrót będzie o wiele bardziej przekonujący.

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 bajtów

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

Wypróbuj online! (ale zabij to natychmiast, nieskończona pętla)

Z 1-sekundową pauzą: 56 bajtów

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

Wypróbuj online! (ponownie, nieskończona pętla)

Python 3 , 193 bajtów

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

Nie golfił

def c a):
    e = ''; s = len (a); l = int (s / 2); b = zakres (y); m = '\ n' * l;
    drukuj (m, a, m);
    dla x in b: print (e * x, a [x]);
    dla x in b: print (e * l, a [x]);
    dla x in b: print (e * (s-1-x), a [x]); 
a = input ();
podczas gdy prawda:
    c (a);
    c (a [:: - 1]);

Rekurencyjny, 177 bajtów

(awaria po kilku sekundach)

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

Nie golfił

def c a):
    e = ''; s = len (a); l = int (s / 2); b = zakres (y); m = '\ n' * l;
    drukuj (m, a, m);
    dla x in b: print (e * x, a [x]);
    dla x in b: print (e * l, a [x]);
    dla x in b: print (e * (s-1-x), a [x]);
    c (a [:: - 1])
c (input ());

Inne rozwiązanie, 268 bajtów

import itertools as 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]) dla x w zakresie (zakresach) )); 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]);

Nie golfił

import itertools jako 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]) dla xw zakresie (s )))
    print (m, a, m, t.join (h [:: 3]), t.join (h [1 :: 3]), t.join (h [2 :: 3]), sep = t, end = '');
a = input ();
podczas gdy prawda:
    wa);
    w (a [:: - 1]);

Pyth, 48 bajtów

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

Wypróbuj online! (Uwaga: jest to wersja, która nie zapętla się na zawsze, ponieważ spowodowałaby awarię interpretera).

Bezwstydnie przetłumaczone z rozwiązania Python 3 przez @ByHH .

Jak to działa:

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