Pour ce défi, vous allez créer une fonction (votre fonction peut être un programme complet) qui prend une liste en entrée et renvoie une permutation de cette liste. Votre fonction doit respecter les exigences suivantes.

• Elle doit être déterministe.

• Composer votre fonction avec elle-même un nombre variable de fois devrait être capable d'obtenir une liste de n'importe laquelle de ses permutations.

Il s'agit d'une question de code-golf, donc les réponses seront notées en octets, avec moins d'octets étant mieux.

Règles supplémentaires

• Vous pouvez prendre tout type de liste, ( [Integer], [String], [[Integer]]) aussi longtemps qu'il

  • Peut être non vide
  • Peut contenir des objets distincts avec au moins 16 valeurs possibles. (Vous ne pouvez pas utiliser un Haskell [()]et prétendre que votre fonction est id)
  • Peut contenir des objets en double (pas d'ensembles)

• Vous pouvez écrire un programme ou une fonction, mais vous devez respecter les E / S standard.

CJam (11 octets)

{_e!_@a#(=}

Démo en ligne montrant le cycle complet d'une liste de quatre éléments avec un élément en double.

Dissection

{      e# Define a block
  _e!  e#   Find all permutations of the input. Note that if there are duplicate
       e#   elements in the input then only distinct permutations are produced.
       e#   Note also that the permutations are always generated in lexicographic
       e#   order, so the order is independent of the input.
  _@a# e#   Find the index of the input in the list
  (=   e#   Decrement and get the corresponding element of the list
       e#   Incrementing would also have worked, but indexing by -1 feels less
       e#   wrong than indexing by the length, and makes this more portable to
       e#   GolfScript if it ever adds a "permutations" built-in
}

Mathematica + Combinatorica (package intégré) 34 octets

19 octets pour charger le package et 15 pour la fonction.

<<"Combinatorica`";NextPermutation

Usage:

%@{c, b, a}

Sans le intégré, 61 octets

Extract[s=Permutations[Sort@#],Mod[s~Position~#+1,Length@s]]&

Combinatorica est censé être entièrement intégré à Mathematica, mais je pense que la fonction NextPermutation a été négligée.

Python 3 , 90 octets

from itertools import*
def f(l):p=[*permutations(sorted(l))];return p[-~p.index(l)%len(p)]

Essayez-le en ligne!

C ++, 42 octets

#include <algorithm>
std::next_permutation

Cette opération exacte est intégrée dans C ++.

JavaScript (ES6), 145 139 137 134 108 octets

25 octets sauvés grâce à @Neil!

Prend la saisie sous forme de tableau de caractères alphabétiques. Renvoie la permutation suivante sous forme d'un autre tableau.

a=>(t=x=y=-1,a.map((v,i)=>v<a[i+1]?(t=v,x=i):y=i>x&v>t?i:y),a[x]=a[y],a[y]=t,a.concat(a.splice(x+1).sort()))

Comment?

Il s'agit d'une génération en ordre lexicographique qui traite les 4 étapes suivantes à chaque itération:

1. Trouver le plus grand index X tel que a [X] <a [X + 1]

   a.map((v, i) => v < a[i + 1] ? (t = v, x = i) : ...)

2. Trouver le plus grand indice Y supérieur à X tel que a [Y]> a [X]

   a.map((v, i) => v < a[i + 1] ? ... : y = i > x & v > t ? i : y)

3. Échangez la valeur d' un [X] avec celle d' un [Y]

   a[x] = a[y], a[y] = t

4. Trier la séquence de [X + 1] jusqu'à et y compris l'élément final, par ordre lexicographique croissant

   a.concat(a.splice(x + 1).sort())

Exemple:

Démo

let f =

a=>(t=x=y=-1,a.map((v,i)=>v<a[i+1]?(t=v,x=i):y=i>x&v>t?i:y),a[x]=a[y],a[y]=t,a.concat(a.splice(x+1).sort()))

for(a = ["A", "B", "C", "D"], n = 0; n < 25; n++) {
  console.log(a.join(','));
  a = f(a);
}

Gelée , 6 octets

Œ¿’œ?Ṣ

Parcourt les permutations dans l'ordre lexicographique décroissant.

Essayez-le en ligne!

Comment ça fonctionne

Œ¿’œ?Ṣ  Main link. Argument: A (array)

Œ¿      Compute the permutation index n of A, i.e., the index of A in the
        lexicographically sorted list of permutations of A.
  ’     Decrement the index by 1, yielding n-1.
     Ṣ  Sort A.
   œ?   Getthe (n-1)-th permutation of sorted A.

C, 161 octets

Algorithme O (n) réel.

#define S(x,y){t=x;x=y;y=t;}
P(a,n,i,j,t)int*a;{for(i=n;--i&&a[i-1]>a[i];);for(j=n;i&&a[--j]<=a[i-1];);if(i)S(a[i-1],a[j])for(j=0;j++<n-i>>1;)S(a[i+j-1],a[n-j])}

Exemple d'utilisation:

int main(int argc, char** argv) {
    int i;
    int a[] = {1, 2, 3, 4};

    for (i = 0; i < 25; ++i) {
        printf("%d %d %d %d\n", a[0], a[1], a[2], a[3]);
        P(a, 4);
    }

    return 0;
}

Python 2 , 154 octets

x=input()
try:exec'%s=max(k for k in range(%s,len(x))if x[%s-1]<x[k]);'*2%tuple('i1kjii');x[i-1],x[j]=x[j],x[i-1];x[i:]=x[:i-1:-1]
except:x.sort()
print x

Essayez-le en ligne!

Gelée , 10 octets

ṢŒ!Q©i⁸‘ị®

Essayez-le en ligne!

Trier> toutes les permutations> trouver une entrée> ajouter 1> indexer dans "toutes les permutations"

05AB1E , 7 octets

œêD¹k>è

Essayez-le en ligne!

PHP , 117 octets

Prend entrée / sortie comme liste de chaînes de lettres inférieures

$a=str_split($s=$argn);rsort($a);if(join($a)!=$s)for($n=$s;($c=count_chars)(++$n)!=$c($s););else$n=strrev($s);echo$n;

Essayez-le en ligne!