Bu sitedeki kod hızla tükeniyor. Yenilenebilir iplere yatırım yapmamız gerekiyor. Bu nedenle, bir dize alan ve bir yel değirmenine dönüştüren bir program yazmalısınız.

Meydan okuma

Örnek olarak basit bir rüzgar değirmeni ipi ele alalım. Dizeyi al abc. Pivot bu durumda merkez karakteri vardır b. Dize 3 karakter uzunluğunda olduğundan, her çıktı tam olarak üç satır uzunluğunda ve üç karakter genişliğinde olacaktır. İşte 1. adımdaki çıktınız. (Boşluğa dikkat edin)

ABC

Bir sonraki adıma geçmek için, pivotun çevresindeki her karakteri saat yönünde döndürün. Adım 2:

bir
 b
  c

3-8 arası adımlar şunlardır:

 bir
 b
 c

  bir
 b
c

cba

c
 b
  bir

 c
 b
 bir

  c
 b
bir

Ve dokuzuncu adımda, orijinal dize tam daire etrafında gelir:

ABC

bTüm zaman aynı yerde kaldı unutmayın . Bunun nedeni bpivot karakteridir. Dizeyi giriş olarak alan ve program kapatılıncaya kadar bu diziyi tekrar tekrar yazdıran bir program veya işlev yazmalısınız.

Açıklamalar

• Tüm giriş dizelerinde tek sayıda karakter olacaktır. (Böylece her yel değirmeninin bir pivotu olur)

• Sorunu basit tutmak için, tüm dizeler yalnızca büyük ve küçük harf alfabe karakterleri içerir.

• Çıktı len(input_string)karakterleri geniş ve uzun olmalıdır.

• Sonsuza kadar dönmeye ve döngü yapmaya devam ettiğiniz sürece dizinin hangi adımında başladığınız önemli değildir.

Daha fazla Test IO:

Yazı zaten oldukça uzun olduğundan, işte "fırıldak" çıktısına bir bağlantı :

Kenar notu:

Bunun bir yel değirmeni olması gerektiği için, küçük bir gecikme veya her adım arasında bir kullanıcı girişi ile canlandırmak için bazı kazan plakası kodu eklemeniz harika olurdu. Ancak, bazı dillerde zaman yerleşikleri bulunmadığından, bu zorunlu değildir. Gönderinizin rakip kısmı diziyi olabildiğince hızlı yazdırabilir.

MATL , 35 33 21 bayt

jtn2/kYaG1$Xd`wtD3X!T

Aşağıdaki yel değirmeni canlandıracak ( 26 bayt )

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

Çevrimiçi Demo

Bu sürümde, Xxekranın temizleneceğini belirtir ve 1Y.1 saniyelik bir duraklamadır.

açıklama

Temel fikir, girdinin iki versiyonunu oluşturmak istiyoruz. "Dikey" bir versiyon

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

Ve bir "köşegen" versiyon

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

Bu iki sürümü yığının üzerine itiyoruz. Döngü boyunca her seferinde, yığının sırasını değiştiririz ve üstünü saat yönünde döndürürüz.

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 bayt

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 bayt

Kod:

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

Çevrimiçi deneyin! . Çalıştırdıktan hemen sonra öldür düğmesine bastığınızdan emin olun, çünkü sonsuz bir döngüye girer.

Yakut, 122 119 bayt

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

Test programında uyku ile birlikte hareketsiz versiyon

Tam konsol yüksekliğinde dönüş çok ikna edici değil. Ancak yüksekliği giriş dizesinin uzunluğuna düşürürseniz, dönüş çok daha ikna edicidir.

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 bayt

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

Çevrimiçi deneyin! (ama hemen öldür, sonsuz döngü)

1 saniyelik duraklama ile: 56 bayt

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

Çevrimiçi deneyin! (yine sonsuz döngü)

Python 3 , 193 bayt

def c (a): e = ''; s = len (a); l = int (s / 2); b = aralık (lar); m = '\ n' * l; baskı (m, a, m ); b için x için: baskı (e * x, a [x]); b için x için: baskı (e * l, a [x]); b için x için: baskı (e * (s-1- x) bir [x]); a = giriş (); Doğru: c (a); c (a [:: - 1]);

Ungolfed

def c (a):
    e = ''; s = len (a); l = int (s / 2); b = aralık (lar); m = '\ n' * l;
    (M, a, m) yazdırır;
    x in b için: baskı (e * x, a [x]);
    x in b için: baskı (e * l, a [x]);
    x in b için: baskı (e * (s-1-x), a [x]); 
a = girişi ();
True iken:
    CA);
    c (a [:: - 1]);

Yinelemeli, 177 bayt

(birkaç saniye sonra çöküyor)

def c (a): e = ''; s = len (a); l = int (s / 2); b = aralık (lar); m = '\ n' * l; baskı (m, a, m ); b için x için: baskı (e * x, a [x]); b için x için: baskı (e * l, a [x]); b için x için: baskı (e * (s-1- x) bir [x]) c (a [:: - 1]); c (giriş ());

Ungolfed

def c (a):
    e = ''; s = len (a); l = int (s / 2); b = aralık (lar); m = '\ n' * l;
    (M, a, m) yazdırır;
    x in b için: baskı (e * x, a [x]);
    x in b için: baskı (e * l, a [x]);
    x in b için: baskı (e * (s-1-x), a [x]);
    c (a [:: - 1])
c (giriş ());

Başka bir çözüm, 268 bayt

itertools'u i olarak içe aktar; def w (a): e = ''; s = len (a); l = int (s / 2); t = '\ n'; m = (l-1) * t; h = aralık (lar) da x için liste (i.chain.from_iterable ((e * x + a [x], e * l + a [x], e * (s-1-x) + a [x]) )), baskı (m, a, m, t.join (h [:: 3]), t.join (s [1 :: 3]), t.join (h [2 :: 3]), sep = t, son = ''); a = giriş (); Doğru: w (a); w (a [:: - 1]);

Ungolfed

itertools'u i olarak içe aktarma;
def w (a):
    e = ''; s = len (a); l = int (s / 2); t = '\ n'; m = (l-1) * t;
    h = aralık (lar) için x için liste (i.chain.from_iterable ((e * x + a [x], e * l + a [x], e * (s-1-x) + a [x]) )))
    baskı (m, A, m, t.join (h [:: 3]), t.join (s [1 :: 3]), t.join (h [2 :: 3]), sep = t, ) '' = uç uca gelir;
a = girişi ();
True iken:
    WA);
    W, (a [:: - 1]);

Pyth, 48 bayt

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

Çevrimiçi deneyin! (Not: Bu, sonsuza kadar döngü yapmayan bir sürümdür, çünkü yorumlayıcıyı çökertecektir.)

@ByHH tarafından Python 3 çözümünden utanmadan tercüme edildi .

Nasıl çalışır:

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