Код на этом сайте быстро истощается. Нам нужно инвестировать в возобновляемые источники. Поэтому вы должны написать программу, которая берет строку и преобразует ее в ветряную мельницу.

Соревнование

Давайте возьмем в качестве примера простую ветряную мельницу. Возьми струну abc. В этом случае ось является центральным персонажем b. Поскольку длина строки составляет 3 символа, каждый вывод будет иметь ровно три строки и три символа в ширину. Вот ваш вывод на шаге 1. (Обратите внимание на пробел)

азбука

Чтобы получить следующий шаг, поверните каждый символ вокруг оси по часовой стрелке. Вот шаг 2:

a
 б
  с

Вот шаги 3-8:

 
 б
 с

  
 б
с

сЬа

с
 б
  

 с
 б
 

  с
 б

И на девятом шаге он проходит полный круг к исходной строке:

азбука

Обратите внимание, что все время bоставались на одном месте. Это потому, что bэто основной персонаж. Вы должны написать программу или функцию, которая принимает строку в качестве входных данных и многократно печатает эту последовательность, пока программа не будет закрыта.

Разъяснения

• Все входные строки будут иметь нечетное количество символов. (Чтобы каждая ветряная мельница имела опору)

• Чтобы упростить задачу, все строки будут содержать только прописные и строчные буквы алфавита.

• Вывод должен быть len(input_string)широким и высоким.

• Неважно, с какого шага последовательности вы начинаете, до тех пор, пока вы продолжаете вращаться и зацикливаться вечно.

Еще тест IO:

Поскольку сообщение уже довольно длинное, вот ссылка на вывод для "windmill":

Примечание:

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

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

Попробуйте онлайн! (опять же, бесконечный цикл)

Python 3 , 193 байта

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

Ungolfed

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

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

(сбой через несколько секунд)

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

Ungolfed

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

Другое решение, 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 в диапазоне (ах) )); печати (м, а, т, t.join (ч [:: 3]), t.join (ч [1 :: 3]), t.join (ч [2 :: 3]), сентябрь = t, end = ''); a = input (); в то время как True: w (a); w (a [:: - 1]);

Ungolfed

импортировать itertools как я;
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 )))
    печать (м, а, т, t.join (ч [:: 3]), t.join (ч [1 :: 3]), t.join (ч [2 :: 3]), сентябрь = т, конец = '');
а = вход ();
пока верно:
    ш (а);
    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))