Fannkuch là một chương trình điểm chuẩn cổ điển. Cái tên này xuất phát từ tiếng Đức "Pfannkuchen" - bánh kếp - vì sự giống nhau của thuật toán với việc lật các chồng bánh kếp. Một dãy số Fannkuch được hình thành như sau:

Lấy một hoán vị của {1 ..... n}, ví dụ: {4.2,1,5,3}. Lấy phần tử đầu tiên, ở đây 4 và đảo ngược thứ tự của 4 phần tử đầu tiên: {5,1,2,4,3}. Lặp lại điều này cho đến khi phần tử đầu tiên là 1, vì vậy lật sẽ không thay đổi gì thêm: {3,4,2,1,5}, {2,4,3,1,5}, {4.2,3, 1,5}, {1,3,2,4,5}

Bạn phải viết một chương trình hoặc hàm tính toán một chuỗi giống Fannkuch cho các chuỗi ký tự chữ cái. Thay vì sử dụng các con số để chỉ ra có bao nhiêu yếu tố của danh sách nên được lật mỗi lần, nên sử dụng vị trí của một chữ cái trong bảng chữ cái. Ví dụ, một hàng đầu csẽ chỉ ra rằng bạn nên đảo ngược thứ tự của 3 phần tử đầu tiên, trong khi một phần đầu achỉ ra rằng chuỗi đã hoàn tất.

Đầu vào

Đầu vào sẽ được cung cấp dưới dạng chuỗi thông qua stdin hoặc dưới dạng đối số hàm. Chuỗi sẽ chứa từ 1 đến 26 chữ cái viết thường. Các chuỗi sẽ không chứa các chữ cái có chỉ số tương đương sẽ khiến thuật toán Fannkuch lật nhiều phần tử hơn so với tồn tại.

Đầu ra

Các chương trình hoặc hàm nên trả về hoặc in để xuất ra chuỗi các thuật ngữ được tạo bằng cách áp dụng thuật toán Fannkuch cho đến khi agặp phải một hàng đầu , bao gồm cả chuỗi ban đầu. Ví dụ: nếu đầu vào là bca, bạn có thể in:

bca
cba
abc

Kết quả được in có thể sử dụng bất kỳ dấu phân cách hợp lý, dòng mới, v.v ... Mọi sự lựa chọn khoảng trắng đều được chấp nhận.

Một ví dụ khác, nếu đầu vào của bạn là eabdcbạn có thể trả về:

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

Quy tắc và chấm điểm

Đây là code-golf - chương trình chiến thắng ngắn nhất. Lỗ hổng tiêu chuẩn không được phép.

Bình thường, 16 byte

.u+_<NJhxGhN>NJz

Trình diễn.

Tính năng "lặp lại cho đến khi nó ngừng thay đổi" các chức năng giảm của Pyth thực sự tiện dụng ở đây. Điều này được sử dụng với .u, hàm giảm tích lũy, để xuất tất cả các kết quả. Cơ thể của sự giảm bớt là ngây thơ nhất có thể, nhưng tôi không thể tìm thấy bất cứ điều gì tốt hơn.

T-SQL, 213 byte

Tất nhiên là SQL, nó thực sự rất lớn, nhưng thật thú vị. Được tạo như một hàm bảng nội tuyến bằng cách sử dụng truy vấn CTE đệ quy.

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

Mở rộng

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

Được sử dụng như sau

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

(5 row(s) affected)

CJam, 22 byte

Đây là một hàm ẩn danh nhận một chuỗi trên ngăn xếp và trả về một danh sách các chuỗi trên ngăn xếp.

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

Dùng thử trực tuyến tại đây

Python 2, 59 byte

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

Tôi đoán đây là một câu trả lời khá đơn giản. Sử dụng đệ quy và cú pháp lát của Python. Gọi là : p('eabdc').

SAS, 131 byte

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;

Một thói quen cuộc gọi FCMP. Nongolfed bên dưới (với một kiểm tra bổ sung tôi rất khuyến khích khi SAS gặp sự cố nếu một thói quen FCMP đi vào một vòng lặp vô hạn).

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 byte

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

Cách sử dụng: f "eabdc"-> ["eabdc","cdbae","bdcae","dbcae","acbde"].

K5, 21 byte

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

Đã lưu 5 byte nhờ @JohnE và một byte khác bằng cách sắp xếp lại một biểu thức.

Lần đầu tiên trên trái đất, tôi nghĩ K đã đánh bại CJam!

Phiên bản 27 byte

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

Bất kỳ chiến thuật phức tạp hơn tôi nghĩ về việc mất nhiều byte hơn.