Fannkuch klasik bir kıyaslama programıdır. Adı, algoritmanın krep yığınlarını çevirme benzerliği için Alman "Pfannkuchen" - krep - geliyor. Bir Fannkuch sayı dizisi aşağıdaki gibi oluşturulur:

{1 ..... n} için bir permütasyon alın, örneğin: {4,2,1,5,3}. Burada 4 olan ilk elemanı alın ve ilk 4 elemanın sırasını tersine çevirin: {5,1,2,4,3}. İlk öğe 1 olana kadar bunu tekrarlayın, bu nedenle çevirme daha fazla bir şey değiştirmeyecektir: {3,4,2,1,5}, {2,4,3,1,5}, {4,2,3, 1,5}, {1,3,2,4,5}

Alfabetik karakter dizeleri için Fannkuch benzeri bir diziyi hesaplayan bir program veya işlev yazmalısınız. Her seferinde listedeki kaç öğenin çevrilmesi gerektiğini belirtmek için sayılar kullanmak yerine, bir harfin alfabedeki konumu kullanılmalıdır. Örneğin, bir satır caralığı, ilk 3 öğenin sırasını tersine çevirmeniz gerektiğini belirtirken, satır aralığı asıralamanın tamamlandığını gösterir.

Giriş

Giriş stdin aracılığıyla bir dize olarak veya bir işlev bağımsız değişkeni olarak sağlanacaktır. Dize, 1 ile 26 arasında küçük harf içerir. Dizeler, eşdeğeri dizini Fannkuch algoritmasının var olandan daha fazla öğe döndürmesine neden olacak harfler içermez.

Çıktı

Programlar veya işlevler a, ilk dize de dahil olmak üzere bir öndeki ile karşılaşılana kadar Fannkuch algoritması uygulanarak üretilen terimlerin sırasını döndürmek veya yazdırmak için yazılmalıdır . Örneğin, giriş ise bca, yazdırabilirsiniz:

bca
cba
abc

Basılı sonuçlar makul ayırıcıları, satırsonlarını, vb. Kullanabilir. Herhangi bir beyaz alan seçeneği kabul edilebilir.

Başka bir örnek olarak, girdiniz şu eabdcşekilde dönebilir:

("eabdc"
 "cdbae"
 "bdcae"
 "dbcae"
 "acbde")

Kurallar ve Puanlama

Bu kod golf - en kısa program kazanır. Standart Loopholes'a izin verilmiyor.

Pyth, 16 bayt

.u+_<NJhxGhN>NJz

Gösteri.

Pyth'in azaltma işlevlerinin "değişene kadar tekrar et" özelliği burada gerçekten kullanışlıdır. Bu, .utüm sonuçları çıktılamak için kümülatif azaltma işleviyle birlikte kullanılır . Azaltmanın bedeni olabildiğince naif, ama daha iyi bir şey bulamadım.

T-SQL, 213 bayt

Tabii ki SQL olmak gerçekten büyük, ama yapmak ilginçti. Özyinelemeli bir CTE sorgusu kullanılarak satır içi tablo işlevi olarak oluşturulur.

CREATE FUNCTION F(@ CHAR(26))RETURNS TABLE RETURN WITH R AS(SELECT @ S UNION ALL SELECT CAST(STUFF(S,1,ASCII(LEFT(S,1))-96,REVERSE(LEFT(S,ASCII(LEFT(S,1))-96)))AS CHAR(26))FROM R WHERE LEFT(S,1)<>'a')SELECT*FROM R

Expanded

CREATE FUNCTION F(@ CHAR(26))
RETURNS TABLE 
RETURN WITH R AS(
    SELECT @ S            -- Initial string as an anchor for the recursion
    UNION ALL 
    SELECT CAST(
        STUFF(                                    -- Stuff into 
            S,                                    -- string S
            1,                                    -- from position 1
            ASCII(LEFT(S,1))-96,                  -- to index value of first char
            REVERSE(LEFT(S,ASCII(LEFT(S,1))-96))  -- the reverse of the index first chars
            )
        AS CHAR(26))
    FROM R 
    WHERE LEFT(S,1)<>'a'  -- recurse until first char is a
)SELECT*FROM R

Aşağıdaki gibi kullanılır

SELECT * FROM F('eabdc')
S
--------------------------
eabdc                     
cdbae                     
bdcae                     
dbcae                     
acbde                     

(5 row(s) affected)

CJam, 22 bayt

Bu, yığında bir dize alan ve yığında bir dize listesi döndüren anonim bir işlevdir.

{_,{_0='`-/(W%\+s_}*]}

Buradan çevrimiçi deneyin

Python 2, 59 bayt

def p(l):
 print l;o=ord(l[0])-97
 if o:p(l[o::-1]+l[o+1:])

Sanırım bu oldukça basit bir cevap. Özyineleme ve Python'un dilim sözdizimini kullanır. Olarak çağrı: p('eabdc').

SAS, 131 bayt

sub a(s$);outargs s;put s;do while(b ne 1);b=rank(char(s,1))-96;substr(s,1,b)=reverse(substr(s,1,b));if b>1 then put s;end;endsub;

Bir FCMP çağrı rutini. Aşağıda Nongolfed (ekstra bir kontrol ile bir FCMP rutini sonsuz bir döngüye girerse SAS çökmesini tavsiye ederim).

options cmplib=work.funcs;
proc fcmp outlib=work.funcs.funcs;
  sub a(s$);
    outargs s;
    put s=;
    do while (b ne 1 and z<1e5);
        b=rank(char(s,1))-96;
        substr(s,1,b) = reverse(substr(s,1,b));
        if b>1 then put s=;
        z+1;
    end;
  endsub;
quit;

Haskell, 78 bayt

f l@(h:_)|h=='a'=[l]|1<2=l:f(reverse(take d l)++drop d l)where d=fromEnum h-96

Kullanımı: f "eabdc"-> ["eabdc","cdbae","bdcae","dbcae","acbde"].

K5, 21 bayt

{(|v#x),(v:*x-96)_x}\

@JohnE ve başka bir bayt sayesinde bir ifadeyi yeniden düzenleyerek 5 bayt kaydedildi.

Yeryüzünde ilk kez, sanırım K CJam'ı dövdü!

27 baytlık sürüm

(~97=*){(|v#x),(v:-96+*x)_x}\

Haskell, 68

f l@(x:_)|x<'b'=[l]|(x,y)<-splitAt(fromEnum x-96)l=l:f(reverse x++y)

Düşündüğüm daha karmaşık bir taktik daha fazla bayt aldı.