अलफैबेटिक फैन्चुक

Question

Fannkuch एक क्लासिक बेंचमार्क प्रोग्राम है। नाम जर्मन "Pfannkuchen" से आता है - पेनकेक्स- पेनकेक्स के ढेर के कतरन के एल्गोरिथ्म के समानता के लिए। संख्याओं का एक फेनुच क्रम निम्नानुसार बनता है:

उदाहरण के लिए {1 ..... n} का क्रमचय लें: {4,2,1,5,3}। पहले तत्व को लें, यहां 4, और पहले 4 तत्वों के क्रम को उल्टा करें: {5,1,2,4,3}। इसे तब तक दोहराएं जब तक कि पहला तत्व 1 न हो जाए, इसलिए फ़्लिपिंग कुछ और नहीं बदलेगी: {3,4,2,1,5}, {2,4,3,1,5}, {4,2,3 1,5}, {1,3,2,4,5}

आपको एक प्रोग्राम या फ़ंक्शन लिखना है जो वर्णमाला वर्णों के तार के लिए एक फेनचुक-जैसे अनुक्रम की गणना करता है। प्रत्येक बार सूची के कितने तत्वों को फ़्लिप किया जाना चाहिए यह इंगित करने के लिए संख्याओं का उपयोग करने के बजाय, वर्णमाला में एक अक्षर की स्थिति का उपयोग किया जाना चाहिए। उदाहरण के लिए, एक अग्रणी cइंगित करेगा कि आपको पहले 3 तत्वों के क्रम को उलट देना चाहिए, जबकि एक अग्रणी aइंगित करता है कि अनुक्रम पूरा हो गया है।

इनपुट

इनपुट को स्ट्रिंग के माध्यम से या फ़ंक्शन तर्क के रूप में प्रदान किया जाएगा। स्ट्रिंग में 1 और 26 अलग-अलग लोअरकेस अक्षर होंगे। स्ट्रिंग्स में ऐसे अक्षर नहीं होंगे जिनके समतुल्य सूचकांक फेनचुक एल्गोरिदम को मौजूद से अधिक तत्वों को फ्लिप करने का कारण होगा।

उत्पादन

प्रोग्राम या फ़ंक्शंस लौटने चाहिए या प्रिंट करना चाहिए जब तक aकि प्रारंभिक स्ट्रिंग सहित एक प्रमुख सामना नहीं किया जाता है, तब तक फन्चुक एल्गोरिदम को लागू करने से उत्पन्न होने वाले शब्दों के अनुक्रम को रोक दिया जाए । उदाहरण के लिए, यदि इनपुट है bca, तो आप प्रिंट कर सकते हैं:

bca
cba
abc

मुद्रित परिणाम किसी भी उचित विभाजक का उपयोग कर सकते हैं- अल्पविराम, नए अंक, आदि। व्हॉट्सएप का कोई भी विकल्प स्वीकार्य है।

एक अन्य उदाहरण के रूप में, यदि आपका इनपुट है eabdcतो आप वापस लौट सकते हैं:

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

नियम और स्कोरिंग

यह कोड-गोल्फ है - सबसे छोटा कार्यक्रम जीतता है। स्टैंडर्ड लूपहोल्स को बंद कर दिया गया है।

Answer 1

पायथ, 16 बाइट्स

.u+_<NJhxGhN>NJz

प्रदर्शन।

"पुनरावृत्ति जब तक यह बदलना बंद हो जाता है" पायथ के कम किए गए कार्यों की विशेषता यहां वास्तव में आसान है। यह .uसभी परिणामों को आउटपुट करने के लिए, संचयी कम फ़ंक्शन के साथ प्रयोग किया जाता है । घट का शरीर उतना ही भोला है, लेकिन मुझे कुछ बेहतर नहीं मिला।

Answer 2

टी-एसक्यूएल, 213 बाइट्स

बेशक एसक्यूएल है यह वास्तव में बहुत बड़ा है, लेकिन यह करना दिलचस्प था। एक पुनरावर्ती CTE क्वेरी का उपयोग करके इनलाइन टेबल फ़ंक्शन के रूप में बनाया गया।

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

विस्तारित

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

निम्नानुसार उपयोग किया जाता है

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

(5 row(s) affected)

Answer 3

सीजेएम, 22 बाइट्स

यह एक अनाम फ़ंक्शन है जो स्टैक पर स्ट्रिंग लेता है और स्टैक पर स्ट्रिंग की एक सूची देता है।

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

इसे यहाँ ऑनलाइन आज़माएँ

Answer 4

पायथन 2, 59 बाइट्स

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

मुझे लगता है कि यह एक सीधा जवाब है। पुनरावृत्ति और पायथन के स्लाइस सिंटैक्स का उपयोग करता है। के रूप में कॉल करें: p('eabdc')।

Answer 5

एसएएस, 131 बाइट्स

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;

एक FCMP कॉल रूटीन। नीचे Nongolfed (एक अतिरिक्त जांच के साथ मैं अत्यधिक अनुशंसा करता हूं कि अगर कोई FCMP रूटीन अनंत लूप में प्रवेश करता है तो एसएएस क्रैश हो जाता है)।

---

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;

Comments

अच्छा काम। हमें proc fcmpयहाँ बहुत कुछ नहीं मिलता है।

— एलेक्स ए।

Answer 6

हास्केल, 78 बाइट्स

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

उपयोग: f "eabdc"-> ["eabdc","cdbae","bdcae","dbcae","acbde"]।

Comments

उपयोग करने पर विचार करें splitAt- आप इसे 71 बाइट्स तक ले जा सकते हैं!

— माउंटन व्यूमार्क

@MtnViewMark अच्छी तरह से मैं एक ही एल्गोरिथ्म है, नीचे 68 बाइट्स के लिए लगता है

— गर्व हैकर

Answer 7

K5, 21 बाइट्स

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

5 बाइट्स @JohnE और एक अन्य बाइट के लिए धन्यवाद एक अभिव्यक्ति को पुनर्व्यवस्थित करके सहेजा गया।

पृथ्वी पर पहली बार, मुझे लगता है कि K ने CJam को हराया है!

27-बाइट संस्करण

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

Comments

यदि आप "स्कैन" के निश्चित-बिंदु रूप का उपयोग करते हैं, तो आप इसे थोड़ा कम कर सकते हैं।

— जॉनी

@ जॉन धन्यवाद! मुझे महसूस नहीं हुआ कि, जब पहला अक्षर एक है a, तो स्ट्रिंग नहीं बदलेगी।

— kirbyfan64sos

Answer 8

हास्केल, 68

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

किसी भी अधिक जटिल रणनीति मैंने अधिक बाइट्स लेने के बारे में सोचा।