Mã trên trang web này đang nhanh chóng bị cạn kiệt. Chúng ta cần đầu tư vào chuỗi tái tạo. Vì vậy, bạn phải viết một chương trình lấy một chuỗi và chuyển đổi nó thành một cối xay gió.

Các thách thức

Hãy lấy một chuỗi cối xay gió đơn giản làm ví dụ. Lấy chuỗi abc. Các trục là nhân vật trung tâm, trong trường hợp này b. Vì chuỗi dài 3 ký tự, mỗi đầu ra sẽ chính xác cao ba dòng và rộng ba ký tự. Đây là đầu ra của bạn ở bước 1. (Lưu ý khoảng trắng)

abc

Để có được bước tiếp theo, xoay từng ký tự xung quanh trục theo chiều kim đồng hồ. Đây là bước 2:

một
 b
  c

Dưới đây là các bước 3-8:

 một
 b
 c

  một
 b
c

cba

c
 b
  một

 c
 b
 một

  c
 b
một

Và ở bước thứ chín, nó xuất hiện xung quanh vòng tròn đầy đủ cho chuỗi ban đầu:

abc

Lưu ý rằng bở lại cùng một chỗ trong toàn bộ thời gian. Điều này là do bnhân vật trụ cột. Bạn phải viết một chương trình hoặc hàm lấy một chuỗi làm đầu vào và liên tục in ra chuỗi này cho đến khi chương trình được đóng lại.

Làm rõ

• Tất cả các chuỗi đầu vào sẽ có một số lượng ký tự lẻ. (Vì vậy, mỗi cối xay gió sẽ có một trục)

• Để giữ cho thử thách đơn giản, tất cả các chuỗi sẽ chỉ chứa các ký tự chữ cái viết hoa và viết thường.

• Đầu ra phải là len(input_string)ký tự rộng và cao.

• Không quan trọng bước nào của chuỗi bạn bắt đầu, chỉ cần bạn tiếp tục xoay vòng và lặp đi lặp lại mãi mãi.

Kiểm tra thêm IO:

Vì bài đăng đã khá dài, nên đây là một liên kết đến đầu ra cho "cối xay gió":

Sidenote:

Vì đây được coi là một cối xay gió, sẽ thật tuyệt vời nếu bạn bao gồm một số mã soạn sẵn để làm động nó với độ trễ thời gian nhỏ hoặc đầu vào của người dùng giữa mỗi bước. Tuy nhiên, vì một số ngôn ngữ không có nội dung thời gian, nên điều này không bắt buộc. Phần cạnh tranh trong bài nộp của bạn chỉ có thể in trình tự càng nhanh càng tốt.

MATL , 35 33 21 byte

jtn2/kYaG1$Xd`wtD3X!T

Sau đây sẽ làm động các cối xay gió ( 26 byte )

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

Demo trực tuyến

Trong phiên bản này, Xxchỉ định xóa màn hình và 1Y.tạm dừng 1 giây.

Giải trình

Ý tưởng cơ bản là chúng tôi muốn tạo hai phiên bản đầu vào. Một phiên bản "trực giao"

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

Và một phiên bản "đường chéo"

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

Chúng tôi đẩy hai phiên bản này lên ngăn xếp. Mỗi lần qua vòng lặp, chúng ta chuyển thứ tự của ngăn xếp và xoay đỉnh trên cùng theo chiều kim đồng hồ.

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 byte

Mã số:

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

Hãy thử trực tuyến! . Hãy chắc chắn nhấn nút kill ngay sau khi bạn chạy nó, bởi vì nó đi vào một vòng lặp vô hạn.

Ruby, 122 119 byte

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

Phiên bản Ungolfed với giấc ngủ, trong chương trình thử nghiệm

Xoay không quá thuyết phục ở chiều cao giao diện điều khiển đầy đủ. Nhưng nếu bạn giảm chiều cao xuống chiều dài của chuỗi đầu vào, việc xoay vòng sẽ thuyết phục hơn rất nhiều.

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 byte

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

Hãy thử trực tuyến! (nhưng giết nó ngay lập tức, vòng lặp vô hạn)

Với thời gian tạm dừng 1 giây: 56 byte

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

Hãy thử trực tuyến! (một lần nữa, vòng lặp vô hạn)

Python 3 , 193 byte

def c (a): e = ''; s = len (a); l = int (s / 2); b = phạm vi (s); m = '\ n' * l; print (m, a, m ); với x in b: print (e * x, a [x]); với x in b: print (e * l, a [x]); với x in b: print (e * (s-1- x), a [x]); a = input (); while True: c (a); c (a [:: - 1]);

Ung dung

def c (a):
    e = ''; s = len (a); l = int (s / 2); b = phạm vi (s); m = '\ n' * l;
    in (m, a, m);
    cho x trong b: in (e * x, a [x]);
    cho x trong b: in (e * l, a [x]);
    cho x trong b: in (e * (s-1-x), a [x]); 
a = đầu vào ();
trong khi Đúng:
    c (a);
    c (a [:: - 1]);

Đệ quy, 177 byte

(sụp đổ sau vài giây)

def c (a): e = ''; s = len (a); l = int (s / 2); b = phạm vi (s); m = '\ n' * l; print (m, a, m ); với x in b: print (e * x, a [x]); với x in b: print (e * l, a [x]); với x in b: print (e * (s-1- x), a [x]); c (a [:: - 1]); c (đầu vào ());

Ung dung

def c (a):
    e = ''; s = len (a); l = int (s / 2); b = phạm vi (s); m = '\ n' * l;
    in (m, a, m);
    cho x trong b: in (e * x, a [x]);
    cho x trong b: in (e * l, a [x]);
    cho x trong b: in (e * (s-1-x), a [x]);
    c (a [:: - 1])
c (đầu vào ());

Một giải pháp khác, 268 byte

nhập itertools dưới dạng i; def w (a): e = ''; s = len (a); l = int (s / 2); t = '\ n'; m = (l-1) * t; h = list (i.chain.from_iterable ((e * x + a [x], e * l + a [x], e * (s-1-x) + a [x]) cho x trong phạm vi (s) )); in (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]);

Ung dung

nhập itertools như i;
def w (a):
    e = ''; s = len (a); l = int (s / 2); t = '\ n'; m = (l-1) * t;
    h = list (i.chain.from_iterable ((e * x + a [x], e * l + a [x], e * (s-1-x) + a [x]) cho x trong phạm vi (s )))
    in (m, a, m, t.join (h [:: 3]), t.join (h [1 :: 3]), t.join (h [2 :: 3]), sep = t, kết thúc = '');
a = đầu vào ();
trong khi Đúng:
    w (a);
    w (a [:: - 1]);

Bình thường, 48 byte

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

Hãy thử trực tuyến! (Lưu ý: đây là phiên bản không lặp mãi, vì nó sẽ làm hỏng trình thông dịch.)

Được dịch một cách đáng xấu hổ từ giải pháp Python 3 của @ByHH .

Làm thế nào nó hoạt động:

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