Fannkuch est un programme de référence classique. Le nom vient de l'allemand "Pfannkuchen" - crêpes - pour la ressemblance de l'algorithme avec le retournement de piles de crêpes. Une séquence de nombres de Fannkuch est formée comme suit:

Prenez une permutation de {1 ..... n}, par exemple: {4,2,1,5,3}. Prenez le premier élément, ici 4, et inversez l'ordre des 4 premiers éléments: {5,1,2,4,3}. Répétez cette opération jusqu'à ce que le premier élément soit un 1, donc le retournement ne changera rien de plus: {3,4,2,1,5}, {2,4,3,1,5}, {4,2,3, 1,5}, {1,3,2,4,5}

Vous devez écrire un programme ou une fonction qui calcule une séquence de type Fannkuch pour les chaînes de caractères alphabétiques. Au lieu d'utiliser des nombres pour indiquer combien d'éléments de la liste doivent être inversés à chaque fois, la position d'une lettre dans l'alphabet doit être utilisée. Par exemple, un cdébut indique que vous devez inverser l'ordre des 3 premiers éléments, tandis qu'un début aindique que la séquence est terminée.

Contribution

L'entrée sera fournie sous forme de chaîne via stdin ou comme argument de fonction. La chaîne contiendra entre 1 et 26 lettres minuscules distinctes. Les chaînes ne contiendront pas de lettres dont l'index équivalent entraînerait l'algorithme de Fannkuch à retourner plus d'éléments qu'il n'en existe.

Production

Les programmes ou les fonctions doivent retourner ou imprimer pour afficher la séquence de termes produite en appliquant l'algorithme de Fannkuch jusqu'à ce qu'un interligne asoit rencontré, y compris la chaîne initiale. Par exemple, si l'entrée est bca, vous pouvez imprimer:

bca
cba
abc

Les résultats imprimés peuvent utiliser des séparateurs, virgules, sauts de ligne raisonnables, etc. Tout choix d'espaces est acceptable.

Comme autre exemple, si votre entrée est, eabdcvous pouvez retourner:

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

Règles et notation

C'est le golf de code - le programme le plus court gagne. Les échappatoires standard ne sont pas autorisées.

Pyth, 16 octets

.u+_<NJhxGhN>NJz

Manifestation.

La fonction "répéter jusqu'à ce qu'il cesse de changer" des fonctions de réduction de Pyth est vraiment pratique ici. Elle est utilisée avec .ula fonction de réduction cumulative pour afficher tous les résultats. Le corps de la réduction est aussi naïf que possible, mais je n'ai rien trouvé de mieux.

T-SQL, 213 octets

Bien sûr, étant SQL, c'est vraiment grand, mais c'était intéressant à faire. Créé en tant que fonction de table en ligne à l'aide d'une requête CTE récursive.

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

Étendu

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

Utilisé comme suit

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

(5 row(s) affected)

CJam, 22 octets

Il s'agit d'une fonction anonyme qui prend une chaîne sur la pile et renvoie une liste de chaînes sur la pile.

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

Essayez-le en ligne ici

Python 2, 59 octets

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

Je suppose que c'est une réponse assez simple. Utilise la récursivité et la syntaxe de tranche de Python. Appelez comme: p('eabdc').

SAS, 131 octets

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;

Une routine d'appel FCMP. Nongolfed ci-dessous (avec une vérification supplémentaire, je recommande fortement que SAS se bloque si une routine FCMP entre dans une boucle infinie).

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 octets

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

Utilisation: f "eabdc"-> ["eabdc","cdbae","bdcae","dbcae","acbde"].

K5, 21 octets

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

5 octets enregistrés grâce à @JohnE et un autre octet en réorganisant une expression.

Pour la première fois sur terre, je pense que K a battu CJam!

Version 27 octets

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

Toute tactique plus compliquée à laquelle je pensais prenait plus d'octets.