Description du défi

Un "dérangement" d'une séquence est une permutation où aucun élément n'apparaît dans sa position d'origine. Par exemple, ECABDest un dérangement de ABCDE, mais CBEDAn'est pas:

ABCDE
 | |   <- B and D are in their orignal positions
CBEDA

Étant donné une séquence, générez-en un dérangement aléatoire.

Remarques

• Vous pouvez prendre soit une chaîne en entrée soit un tableau / liste d'éléments (entiers, caractères, objets ...)

• Au lieu de renvoyer un nouvel objet, vous pouvez modifier un objet existant en échangeant ses éléments

• Chaque dérangement devrait avoir une probabilité égale d'être généré

• Vous pouvez supposer qu'il y a plus d'un élément dans la séquence et qu'aucun n'apparaît plus d'une fois

CJam , 14 octets

q:X{mr_X.=:|}g

Essayez-le en ligne!

Continue à mélanger l'entrée jusqu'à ce qu'elle soit un dérangement.

Explication

q:X   e# Read input and store it in X.
{     e# While the condition at the end of the loop is truthy...
  mr  e#   Shuffle the string.
  _X  e#   Duplicate it and push the input.
  .=  e#   Element-wise equality check.
  :|  e#   Reduce OR over the list, gives something truthy if any character
      e#   remained in its original position.
}g

Gelée , 6 octets

Ẋ=³S$¿

Essayez-le en ligne!

Explication

Ẋ    ¿    Shuffle the given list while this is nonzero for it:
    $       A two-step process:
 =³           Element-wise equality of it and L (the original list)...
   S          Sum the ones in this binary array.

Jonathan Allan a enregistré un octet.

Python, 85 octets

Modifie la liste qui lui est passée (autorisée par la méta et dans la question).

from random import*
def D(l):
 o=l[:]
 while any(x==y for x,y in zip(o,l)):shuffle(l)

Essayez-le en ligne ici!

ES6 (Javascript), 71, 69 octets

L'entrée et la sortie sont des tableaux, devraient fonctionner avec tous les types d'éléments (chaînes, nombres, etc.), à condition qu'ils puissent être comparés à "==".

Golfé

F=s=>(r=[...s]).sort(_=>Math.random()-.5).some((e,i)=>s[i]==e)?F(s):r

Tester

F=s=>(r=[...s]).sort(_=>Math.random()-.5).some((e,i)=>s[i]==e)?F(s):r

F(['A','B','C','D'])
Array [ "D", "C", "A", "B" ]

F(['A','B','C','D'])
Array [ "D", "A", "B", "C" ]

F(['A','B','C','D'])
Array [ "C", "D", "B", "A" ]

F(['A','B','C','D'])
Array [ "D", "C", "B", "A" ]

F(['A','B','C','D'])
Array [ "C", "D", "B", "A" ]

Extrait interactif

F=s=>(r=[...s]).sort(_=>Math.random()-.5).some((e,i)=>s[i]==e)?F(s):r

function G() {
    console.log(F(T.value.split``).join``); 
}

<input id=T value="ABCDEF"><button id=G onclick="G()">GENERATE</button>

Perl 6 , 33 octets

{first (*Zne$_).all,.pick(*)xx *}

Un lambda qui prend en entrée une liste d'entiers ou de caractères et renvoie une nouvelle liste.

S'il doit prendre en charge des listes de valeurs arbitraires , il nedevrait être remplacé par !eqv(+2 octets).

( Essayez-le en ligne. )

Explication:

• { }: Définit un lambda.
• .pick(*): Génère une lecture aléatoire de la liste d'entrée.
• .pick(*) xx *: Crée une séquence infinie paresseuse de tels mélanges.
• (* Zne $_).all: Lambda qui zippe deux listes (son argument *et l' argument externe de lambda $_) avec l' neopérateur (égalité de chaîne négative), produisant une liste de booléens, puis crée une alljonction pour les réduire à un seul état booléen.
• first PREDICATE, SEQUENCE: Prend le premier élément de notre séquence infinie de permutations qui remplit le test de "dérangement".

Brachylog , 19 18 15 13 octets

@~.:?z:#da;?&

Essayez-le en ligne!

Explication

@~.                Output is a shuffle of the input
  .:?z             Zip the output with the input
      :#da         All couples of integers of the zip must be different
          ;      Or
           ?&      Call recursively this predicate with the same input

Perl 6 , 45 octets

{(@^a,{[.pick(*)]}...{none @a Zeqv@$_})[*-1]}

{(@^a,{[.pick(*)]}...{!sum @a Zeqv@$_})[*-1]}

Essayez-le

L'entrée est un tableau de n'importe quoi.

Étendu:

{
  (

    @^a,          # declare parameter, and seed sequence generator

    {             # lambda with implicit parameter ｢$_｣
      [           # store into an array
        .pick(*)  # shuffle ｢$_｣
      ]
    }

    ...           # keep generating the sequence until

    {
      none        # none
      @a          # of the outer blocks input
      Z[eqv]      # is zip equivalent
      @$_         # with the current value being tested
    }

  )[ * - 1 ]      # return the last value
}

MATL, 7 octets

Ceci est une traduction de mon post Octave (et similaire à certaines des autres soumissions ici). J'ai posté mon premier post MATL hier (crack CNR), donc je suppose que ce n'est pas optimal, mais c'est le meilleur que j'ai eu jusqu'à présent.

Pour être honnête, je ne suis pas tout à fait sûr que cela tsoit nécessaire, mais c'est la seule façon de faire en sorte que cela fonctionne. Il est utilisé pour que je puisse comparer l'entrée utilisateur (récupérée avec G), avec la permutation aléatoire. Je pense que je pourrais comparer les deux sans ça, mais ...?

Quoi qu'il en soit, voici:

`Z@tG=a

`          % Loop
 Z@        % Random permutation of input
   t       % Duplicating the stack
    G      % Paste from clipboard G (user input)
     =     % Comparing the random permutation with the input (retrieved from clipboard)
      a    % any(input == random permutation)
           % Implicit end and display

Essayez-le en ligne!

En fait , 13 octets

;;WX╚│♀=ΣWX)X

Essayez-le en ligne!

Explication:

;;WX╚│♀=ΣWX)X
;;             make two copies of input
  WX╚│♀=ΣW     while top of stack is truthy:
   X             discard top of stack
    ╚            shuffle array
     │           duplicate entire stack
      ♀=         compare corresponding elements in shuffled and original for equality
        Σ        sum (truthy if any elements are in the same position, else falsey)
          X)X  discard everything but the derangement

Octave, 56 55 octets

x=input('');while any(x==(y=x(randperm(nnz(x)))));end,y

Nous devons utiliser input('') car ce n'est pas une fonction. De plus, comme je peux choisir d'avoir l'entrée sous forme de chaîne, nous pouvons utiliser l'astuce qui nnz(x)==numel(x).

Explication:

x=input('')            % Self-explanatory
while any(x==y)        % Loop until x==y has only 0s (i.e. no elements are equal)
y=x(randperm(nnz(x)))  % Continue to shuffle the indices and assign x(indices) to y
end                    % End loop
y                      % Display y

Merci à Luis d'avoir remarqué que l'entrée peut être une chaîne, donc j'ai pu utiliser nnzau lieu d' numelenregistrer deux octets.

MATL, 13 octets

Il s'agit d'un effort conjoint de @LuisMendo et moi. Contrairement à de nombreuses autres réponses, celle-ci est déterministe dans le sens où elle n'échantillonne pas les permutations aléatoires jusqu'à ce qu'elle obtienne un dérangement, mais elle génère tous les dérangements et en choisit une au hasard.

Y@tG-!Af1ZrY)

Essayez-le en ligne!

Explication

Y@tG-!Af1ZrY)
Y@             generate all permutatoins
  t            create a duplicate
   G-!A        find the (logical) indices of all valid derangements (where no character of the string is in the same position as the original string)
       f       convert logical to linear indices
        1Zr    choose one of those indices randomly
           Y)  get the derangement (from the ones we generated earlier) at this index

Pyth - 10 9 octets

Cela continue de mélanger l'entrée tandis que l'un des caractères est égal à celui de son index dans l'entrée.

.WsqVHQ.S

Essayez-le en ligne ici .

.W           Iterate while
 s           Sum, this is works as any() on a boolean list
  qV         Vectorized equality
   H         The lambda variable for the check step
   Q         The input
 .S          Shuffle
  (Z)        Lambda variable, implicit
 (Q)         Start .W with input, implicit

Mathematica, 57 octets

#/.x_:>RandomChoice@Select[Permutations@x,FreeQ[#-x,0]&]&

Fonction sans nom prenant une liste de whatevers comme entrée et sortie d'une liste. Après avoir généré toutes les permutations #de l'entrée x, nous ne gardons que celles pour lesquelles l'ensemble #-xdes différences élément par élément ne contient pas a 0; puis nous faisons un choix aléatoire (uniforme) à partir de cet ensemble.

PHP, 85 octets

for($a=$b=str_split($argv[1]);array_diff_assoc($a,$b)!=$a;)shuffle($b);echo join($b);

Copie l'argument chaîne dans deux tableaux, mélange l'un d'eux jusqu'à ce que la différence entre eux (comparant également les index des éléments) soit égale à l'autre. Courez avec -r.

R, 59 octets

z=x=1:length(y<-scan(,""));while(any(x==z))z=sample(x);y[z]

Lit une liste d'éléments dans STDIN, prend la longueur de la liste et commence les plages d'échantillonnage de 1 à la longueur, jusqu'à ce qu'il en trouve un qui ne partage aucun emplacement avec la liste ordonnée. Imprime ensuite cette liste.

Wonder , 32 octets

f\@[/>#I zip#=[#0a\shuf#0]?f a?a

Usage:

f\@[/>#I zip#=[#0a\shuf#0]?f a?a];f[1 2 3 4 5]

Explication

Plus lisible:

f\@[
  some #I zip #= [#0; a\ shuf #0]
    ? f a
    ? a
]

Fonction récursive f. Effectue une comparaison élément par élément entre fla liste d'entrée de et une version mélangée de la liste d'entrée. Si la comparaison donne des valeurs égales, elle fest appelée dans la liste mélangée. Sinon, nous renvoyons simplement la liste mélangée.

Rubis, 67 octets

def f a
while (a.zip(o=a.shuffle).map{|x,y|x-y}.index 0);end
o
end

Octave, 54 53 octets

@(a)((p=perms(a))(L=!any(p==a,2),:))(randi(sum(L)),:)

Générez toutes les permutations de aet sélectionnez au hasard une ligne qui n'a pas d'élément commun avec a.

note: C'est accidentellement la même chose que la réponse @flawr MATL!

Clojure, 94 90 79 octets

#(let[s(shuffle %)](if(not(some(fn[[x y]](= x y))(map vector % s)))s(recur %)))

-4 octets en changeant le conditionnel à l'intérieur de la réduction en an and, et en insérantdone? .

-11 octets en convertissant la réduction en some .

WOOT! Battez PHP.

Méthode de la force brute. Mélange la liste lorsqu'elle n'est pas valide. Cela se termine rapidement stupide étant donné qu'il s'agit d'une méthode de force brute qui ne fait rien pour empêcher les essais en double. Il a trouvé 1000 dearangments d'une longue liste de 1000 éléments en moins d'une seconde.

Non golfé:

(defn dearang [ls]
  (let [s (shuffle ls)
        bad? (some (fn [[x y]] (= x y))
                (map vector ls s))]
    (if (not bad?) s (recur ls))))

Clojure, 56 octets

#(let[s(shuffle %)](if((set(map = % s))true)(recur %)s))

Notez qu'une chaîne ne peut pas être mélangée, doit être traversée seqouvec .

A l'origine j'ai essayé #(first(remove(fn[s]((set(map = % s))true))(iterate shuffle %)))mais l' recurapproche est en effet plus courte queiterate .

La magie est que (set(map = % s))renvoie soit un ensemble de faux, un ensemble de vrais ou un ensemble de vrais et faux. Cela peut être utilisé comme une fonction, s'il contient truealors la réponse est true, sinon fausse nil. =est heureux de prendre deux arguments d'entrée, pas besoin de l'envelopper avec quelque chose.

((set [false]) true)
nil

Peut-être existe-t-il un moyen encore plus court de vérifier si l'une des valeurs est vraie?

APL, 11 octets.

Avec la chaîne dans le bon argument:

⍵[⍋(⍴⍵)?⍴⍵]

Explication

ρ⍵ obtient la longueur (ou la forme) de l'argument de droite.

?renvoie un tableau aléatoire (⍴⍵)de ces nombres.

⍋ retourne la commande d'entre eux afin de s'assurer qu'il n'y a pas de doublons.

⍵[..] représente l'assortiment aléatoire de la chaîne utilisant cet index.