Kode di situs ini cepat habis. Kita perlu berinvestasi dalam string yang terbarukan. Jadi, Anda harus menulis sebuah program yang mengambil string dan mengubahnya menjadi kincir angin.

Tantangan

Mari kita ambil string gilingan angin sederhana sebagai contoh. Ambil talinya abc. The poros adalah karakter pusat, dalam hal ini b. Karena panjang string adalah 3 karakter, setiap output akan memiliki tinggi tepat tiga garis dan lebar tiga karakter. Ini adalah output Anda pada langkah 1. (Perhatikan spasi putih)

abc

Untuk mendapatkan langkah selanjutnya, putar setiap karakter di sekitar pivot searah jarum jam. Inilah langkah 2:

Sebuah
 b
  c

Ini langkah 3-8:

 Sebuah
 b
 c

  Sebuah
 b
c

cba

c
 b
  Sebuah

 c
 b
 Sebuah

  c
 b
Sebuah

Dan pada langkah kesembilan, muncul lingkaran penuh ke string asli:

abc

Perhatikan bahwa btinggal di tempat yang sama sepanjang waktu. Ini karena bkarakter pivot. Anda harus menulis program atau fungsi yang mengambil string sebagai input dan berulang kali mencetak urutan ini hingga program ditutup.

Klarifikasi

• Semua string input akan memiliki jumlah karakter ganjil. (Sehingga setiap kincir angin akan memiliki poros)

• Agar tantangannya sederhana, semua string hanya akan berisi karakter alfabet huruf besar dan kecil.

• Outputnya harus len(input_string)karakter lebar dan tinggi.

• Tidak masalah langkah urutan mana yang Anda mulai, asalkan Anda terus berputar dan berputar selamanya.

Lebih Banyak Tes IO:

Karena posnya sudah cukup panjang, berikut ini tautan ke keluaran untuk "kincir angin":

Sidenote:

Karena ini seharusnya kincir angin, akan luar biasa jika Anda memasukkan beberapa kode boilerplate untuk menghidupkannya dengan penundaan waktu yang kecil atau input pengguna di antara setiap langkah. Namun, karena beberapa bahasa tidak memiliki builtin waktu, ini tidak wajib. Bagian yang bersaing dari kiriman Anda hanya dapat mencetak urutan secepat mungkin.

MATL , 35 33 21 byte

jtn2/kYaG1$Xd`wtD3X!T

Berikut ini akan menghidupkan kincir angin ( 26 byte )

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

Demo online

Dalam versi ini, the Xx ditentukan untuk menghapus layar dan 1Y.adalah jeda 1 detik.

Penjelasan

Ide dasarnya adalah kami ingin membuat dua versi input. Versi "ortogonal"

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

Dan versi "diagonal"

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

Kami mendorong dua versi ini ke tumpukan. Setiap kali melalui loop, kami mengubah urutan tumpukan dan memutar bagian atas searah jarum jam.

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

Kode:

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

Cobalah online! . Pastikan untuk menekan tombol kill tepat setelah Anda menjalankannya, karena itu masuk ke loop tak terbatas.

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

Versi tidak dikoleksi dengan tidur, dalam program uji

Rotasi tidak terlalu meyakinkan pada ketinggian konsol penuh. Tetapi jika Anda mengurangi ketinggian hingga panjang string input, rotasi jauh lebih meyakinkan.

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

Cobalah online! (Tapi segera bunuh, loop tak terbatas)

Dengan jeda 1 detik: 56 byte

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

Cobalah online! (lagi, loop tak terbatas)

Python 3 , 193 byte

def c (a): e = ''; s = len (a); l = int (s / 2); b = rentang (s); m = '\ n' * l; cetak (m, a, m ); untuk x in b: print (e * x, a [x]); untuk x in b: print (e * l, a [x]); untuk x in b: print (e * (s-1- x), a [x]); a = input (); sementara True: c (a); c (a [:: - 1]);

Tidak disatukan

def c (a):
    e = ''; s = len (a); l = int (s / 2); b = rentang (s); m = '\ n' * l;
    cetak (m, a, m);
    untuk x dalam b: cetak (e * x, a [x]);
    untuk x in b: print (e * l, a [x]);
    untuk x dalam b: cetak (e * (s-1-x), a [x]); 
a = input ();
sementara Benar:
    c (a);
    c (a [:: - 1]);

Rekursif, 177 byte

(macet setelah beberapa detik)

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

Tidak disatukan

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

Solusi lain, 268 byte

impor itertools sebagai i; def w (a): e = ''; s = len (a); l = int (s / 2); t = '\ n'; m = (l-1) * t; h = daftar (i.chain.from_iterable ((e * x + a [x], e * l + a [x], e * (s-1-x) + a [x]) untuk x dalam rentang (s) )); cetak (m, a, m, t.join (h [:: 3]), t.join (h [1 :: 3]), t.join (h [2 :: 3]), sep = t, end = ''); a = input (); sedangkan True: w (a); w (a [:: - 1]);

Tidak disatukan

impor itertools seperti saya;
def w (a):
    e = ''; s = len (a); l = int (s / 2); t = '\ n'; m = (l-1) * t;
    h = daftar (i.chain.from_iterable ((e * x + a [x], e * l + a [x], e * (s-1-x) + a [x]) untuk x dalam rentang (s )))
    cetak (m, a, m, t.join (h [:: 3]), t.join (h [1 :: 3]), t.join (h [2 :: 3]), sep = t, end = '');
a = input ();
sementara Benar:
    w (a);
    w (a [:: - 1]);

Pyth, 48 byte

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

Cobalah online! (Catatan: ini adalah versi yang tidak selamanya di-loop, karena akan membuat crash penerjemah.)

Tanpa malu-malu diterjemahkan dari solusi Python 3 oleh @ByHH .

Bagaimana itu bekerja:

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