Код на цьому сайті швидко вичерпується. Нам потрібно інвестувати у відновлювані нитки. Отже, ви повинні написати програму, яка бере рядок і перетворює її на вітряк.

Змагання

Візьмемо для прикладу просту струну вітряного млина. Візьміть рядок abc. В цьому випадку стрижень є центральним символом b. Оскільки рядок має три символи в довжину, кожен висновок буде рівно трьома рядками у висоту та трьома знаками. Ось ваш результат на кроці 1. (Зверніть увагу на пробіли)

абс

Щоб отримати наступний крок, оберніть кожен символ навколо стрілки за годинниковою стрілкою. Ось крок 2:

а
 б
  c

Ось кроки 3-8:

 а
 б
 c

  а
 б
c

cba

c
 б
  а

 c
 б
 а

  c
 б
а

І на дев'ятому кроці відбувається повне коло до початкового рядка:

абс

Зауважте, що bвесь час перебували на одному місці. Це тому, що bє стрижневим символом. Ви повинні написати програму або функцію, яка приймає рядок як вхідний і багаторазово друкує цю послідовність, поки програма не буде закрита.

Роз'яснення

• Усі вхідні рядки матимуть непарну кількість символів. (Так що кожен вітряк матиме стрижень)

• Щоб виклик був простим, усі рядки будуть містити лише верхні та малі символи алфавіту.

• Вихідні дані повинні бути len(input_string)символами широкими та високими.

• Не має значення, на якому кроці послідовності ви починаєте, до тих пір, поки ви продовжуватимете обертання і циклівання назавжди.

Більше тестового IO:

Оскільки пост вже досить довгий, ось посилання на вихід для "вітряка":

Sidenote:

Оскільки це має бути вітряком, було б дивним, якщо ви включите якийсь код котла, щоб анімувати його з невеликою затримкою часу або користувацьким вкладом між кожним кроком. Однак, оскільки деякі мови не мають вбудованого часу, це не є обов'язковим. Конкуруюча частина подання може просто надрукувати послідовність якомога швидше.

MATL , 35 33 21 байт

jtn2/kYaG1$Xd`wtD3X!T

Далі буде оживляти вітряк ( 26 байт )

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

Демонстрація в Інтернеті

У цій версії Xxзадається очищення дисплея, а 1Y.пауза 1 секунда.

Пояснення

Основна ідея полягає в тому, що ми хочемо створити дві версії вхідних даних. "Ортогональна" версія

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

І "діагональна" версія

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

Ці дві версії натискаємо на стек. Щоразу через цикл ми перемикаємо порядок стеки і обертаємо верхню частину за годинниковою стрілкою.

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 байт

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 байти

Код:

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

Спробуйте в Інтернеті! . Не забудьте натиснути кнопку вбити відразу після запуску, бо вона переходить у нескінченний цикл.

Рубі, 122 119 байт

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

Неперевершена версія зі сном, в тестовій програмі

Обертання не дуже переконливе на повній висоті консолі. Але якщо зменшити висоту до довжини вхідного рядка, обертання набагато переконливіше.

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 байт

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

Спробуйте в Інтернеті! (але вбийте його негайно, нескінченна петля)

З 1-секундною паузою: 56 байт

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

Спробуйте в Інтернеті! (знову ж таки, нескінченна петля)

Пітон 3 , 193 байт

def c (a): e = ''; s = len (a); l = int (s / 2); b = range (s); m = '\ n' * l; print (m, a, m ); для x in b: print (e * x, a [x]); для x in b: print (e * l, a [x]); для x in b: print (e * (s-1- х), а [х]); a = вхід (); в той час як True: c (a); c (a [:: - 1]);

Безумовно

def c (a):
    e = ''; s = len (a); l = int (s / 2); b = діапазон (s); m = '\ n' * l;
    друк (м, а, м);
    для x in b: друк (e * x, a [x]);
    для x in b: друк (e * l, a [x]);
    для x in b: друк (e * (s-1-x), a [x]); 
a = вхід ();
істинно:
    в (а);
    c (a [:: - 1]);

Рекурсивна, 177 байт

(аварія через кілька секунд)

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

Безумовно

def c (a):
    e = ''; s = len (a); l = int (s / 2); b = діапазон (s); m = '\ n' * l;
    друк (м, а, м);
    для x in b: друк (e * x, a [x]);
    для x in b: друк (e * l, a [x]);
    для x in b: друк (e * (s-1-x), a [x]);
    c (a [:: - 1])
c (вхід ());

Ще одне рішення, 268 байт

імпортуйте itertools як i; def w (a): e = ''; s = len (a); l = int (s / 2); t = '\ n'; m = (l-1) * t; h = список (i.chain.from_iterable ((e * x + a [x], e * l + a [x], e * (s-1-x) + a [x]) для x у діапазоні (і) )); друк (m, a, m, t.join (h [:: 3]), t.join (h [1 :: 3]), t.join (h [2 :: 3]), sep = t, end = ''); a = input (); в той час як True: w (a); w (a [:: - 1]);

Безумовно

імпортувати itertools як i;
def w (a):
    e = ''; s = len (a); l = int (s / 2); t = '\ n'; m = (l-1) * t;
    h = список (i.chain.from_iterable ((e * x + a [x], e * l + a [x], e * (s-1-x) + a [x]) для x у діапазоні (s )))
    друкувати (m, a, m, t.join (h [:: 3]), t.join (h [1 :: 3]), t.join (h [2 :: 3]), sep = t, кінець = '');
a = вхід ();
істинно:
    w (a);
    w (a [:: - 1]);

Pyth, 48 байт

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

Спробуйте в Інтернеті! (Примітка. Це версія, яка не назавжди циклічна, тому що це призведе до краху інтерпретатора.)

Безсоромно перекладено з рішення Python 3 від @ByHH .

Як це працює:

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