รหัสในเว็บไซต์นี้กำลังจะหมดลงอย่างรวดเร็ว เราจำเป็นต้องลงทุนในสายการผลิตทดแทน ดังนั้นคุณต้องเขียนโปรแกรมที่ใช้สตริงและแปลงเป็นกังหันลม

ความท้าทาย

ลองมาดูตัวอย่างของกังหันลมแบบง่าย abcใช้สตริง เดือยbเป็นตัวละครที่ศูนย์ในกรณีนี้ เนื่องจากสตริงมีความยาว 3 ตัวอักษรเอาต์พุตทุกตัวจะถูกต้องสามบรรทัดสูงและสามตัวอักษรกว้าง นี่คือผลลัพธ์ของคุณในขั้นตอนที่ 1 (หมายเหตุช่องว่าง)

abc

ในการรับขั้นตอนต่อไปให้หมุนตัวละครแต่ละตัวรอบเดือยตามเข็มนาฬิกา นี่คือขั้นตอนที่ 2:

a
 ข
  ค

นี่คือขั้นตอนที่ 3-8:

 
 ข
 ค

  
 ข
ค

CBA

ค
 ข
  

 ค
 ข
 

  ค
 ข

และในขั้นตอนที่เก้ามันจะวนเต็มวงกลมไปยังสตริงเดิม:

abc

โปรดทราบว่า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 วินาที

คำอธิบาย

แนวคิดพื้นฐานคือเราต้องการสร้างอินพุตสองเวอร์ชัน เวอร์ชัน "orthogonal"

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

ลองออนไลน์! . ตรวจสอบให้แน่ใจว่าได้กดปุ่มฆ่าทันทีหลังจากที่คุณเรียกใช้เพราะมันเข้าสู่วงวนไม่สิ้นสุด

Ruby, 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 = พิสัย (s); m = '\ n' * l; พิมพ์ (m, a, m ); สำหรับ x ใน b: print (e * x, a [x]); สำหรับ x in b: print (e * l, a [x]); สำหรับ x in b: print (e * (s-1- x) เป็น [x]); a = input (); ในขณะที่ True: c (a); c (a [:: - 1]);

Ungolfed

def c (a):
    e = ''; s = len (a); l = int (s / 2); b = ช่วง (s); m = '\ n' * l;
    พิมพ์ (m, A, M);
    สำหรับ x ใน b: พิมพ์ (e * x, a [x]);
    สำหรับ x ใน b: พิมพ์ (e * l, a [x]);
    สำหรับ x ใน b: พิมพ์ (e * (s-1-x), [x]); 
A = การป้อนข้อมูล ();
ในขณะที่ True:
    ค (ก);
    ค (ก [:: - 1]);

วนซ้ำ, 177 ไบต์

(ขัดข้องหลังจากไม่กี่วินาที)

def c (a): e = ''; s = len (a); l = int (s / 2); b = พิสัย (s); m = '\ n' * l; พิมพ์ (m, a, m ); สำหรับ x ใน b: print (e * x, a [x]); สำหรับ x in b: print (e * l, a [x]); สำหรับ x in b: print (e * (s-1- x) เป็น [x]); C (ก [:: - 1]); C (อินพุท ());

Ungolfed

def c (a):
    e = ''; s = len (a); l = int (s / 2); b = ช่วง (s); m = '\ n' * l;
    พิมพ์ (m, A, M);
    สำหรับ x ใน b: พิมพ์ (e * x, a [x]);
    สำหรับ x ใน b: พิมพ์ (e * l, a [x]);
    สำหรับ x ใน b: พิมพ์ (e * (s-1-x), [x]);
    ค (ก [:: - 1])
ค (input ());

โซลูชันอื่น 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 ในช่วง (s) )); พิมพ์ (m, A, M, t.join (h [:: 3]) t.join (h [1 :: 3]) t.join (h [2 :: 3]) กันยายน = t, end = ''); a = input (); ในขณะที่ True: w (a); w (a [:: - 1]);

Ungolfed

itertools นำเข้าเป็น 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]) สำหรับ x ในช่วง (s )))
    พิมพ์ (m, A, M, t.join (h [:: 3]) t.join (h [1 :: 3]) t.join (h [2 :: 3]) กันยายน = T, จบ = '');
A = การป้อนข้อมูล ();
ในขณะที่ True:
    W (ก);
    W (ก [:: - 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))