J'ai ce problème dans lequel je voudrais mélanger une liste, mais seulement le faire légèrement. Dis, je veux seulement qu'un petit nombre d'éléments soit déplacé. Y a-t-il un moyen simple de faire cela?
À l'heure actuelle, le meilleur que je puisse penser, construit ma propre méthode est la main, mais y a-t-il un moyen d'utiliser la bibliothèque aléatoire pour le faire pour moi?
6 Réponses :
Utilisez un Fisher-Yates shuffle , mais ne pas courir pour toute la liste. Il suffit d'exécuter une étape pour chaque entrée que vous souhaitez déplacer: 5 étapes pour déplacer 5 entrées, 10 étapes pour déplacer 10 entrées.
Cela ne me semble pas que quelque chose qui fonctionnerait, soin de l'élaboration?
Les boucles Normal F-Y Shuffle sur toute la liste d'une extrémité de l'autre, mélangant toutes les entrées. Je suggère d'arrêter la boucle après quelques itérations, alors seulement quelques entrées de liste sont déplacées. Plutôt que de boucler sur 0 .. N-1, boucle supérieure à 0. 5 Pour déplacer seulement 5 entrées.
Oui, cette idée n'est pas chalette du tout, et autant que je puisse dire, ne fonctionnera pas. Toute l'idée dans F-Y dépend essentiellement de la réalisation de la liste complète.
Tous les articles ne seraient pas également susceptibles d'être déplacés.
@PJS choisissez ensuite les positions pour mélanger au hasard plutôt que en série.
Il y a sortie shuffle dans le module "code> aléatoire" / code> qui prend 1 argument requis list objet et second aléatoire argument aléatoire
aléatoire prend un objet de fonction qui renvoie float de 0.0 à 1,0
Vous pouvez écrire une nouvelle fonction qui reviendra généralement moins de 0,5
Pourriez-vous expliquer comment le deuxième paramètre est utilisé?
shuffle la fonction iTère sur la liste et appelle une fonction aléatoire, si la fonction renvoie le numéro inférieur à 0.5, le chiffre actuel de la liste ne changerait pas la position.
Pour cette raison, j'ai écrit une fonction qui retourne généralement des nombres inférieurs à 0,5
En réalité, l'argument aléatoire ressemble plus à une graine pour le mélange. Random.shauffe (Arr, Lambda: 0.2) Données [5, 3, 4, 1, 6, 7, 8, 9, 2] Toujours.
la source de aléatoire.shauffe suggère qu'il n'est pas conçu être utilisé comme ça. La biaiser à des valeurs plus petites entraînera une approche d'une liste qui a été tournée par un élément.
''.join(partial_shuffle(list('abcdefghijklmnopqrstuvwxyz'), 2))
On pourrait aussi interpréter légèrement em> mélangé en ce sens qu'il existe une probabilité d'éléments de mélange à chaque étape de l'algorithme de pêche-Yates @rossum et @ Meta4 mentionné (au lieu d'avoir un nombre fixe de éléments mélangés). def conditional_fy(l, p):
"""Shuffle elements of a list with a given probability
Args:
l: list
p: shuffle probability
(0: elements are never shuffled,
1: elements are always shuffled)
"""
assert 0 <= p <= 1
for i in range(len(l) - 1, 0, -1):
shuffle = random.random()
if shuffle < p:
j = random.randint(0, i - 1)
l[i], l[j] = l[j], l[i]
Une interprétation est de conserver fortement ou faiblement la commande initiale. La rétention la plus faible serait un shuffé entièrement aléatoire, le plus fort serait de ne pas s'écarter de la commande initiale.
Ceci peut être accompli en créant un tuple consistant à être constitué de l'indice d'origine mis à l'échelle par une constante, plus une certaine aléatoire, suivie de la valeur. Trier les tuples, puis itérer pour récupérer les valeurs d'origine dans leur nouvelle commande. Si le facteur d'échelle de l'indice est proche de zéro, le nouvel ordre sera aléatoire. Si c'est près de 1, les choses auront tendance à être fortement mais ne conservent pas parfaitement leur commande originale. Si c'est plus grand, le résultat devient improbable d'être mélangé. ceci produit, par exemple: Tendance à Shuffle serait déterminé par les magnitudes relatives de Ordonnance et l'écart type dans aléatoire.gauss () .
Pour montrer ce que certaines de ces solutions font, je trouve cela aide à gérer plusieurs fois un algorithme de Monte-Carlo à plusieurs reprises et regarder la distribution
première version de la solution de @ Meta4. p> que nous pouvons exécuter plusieurs fois en faisant: p> si nous imprimons la table des occurrences comme des pourcentages que nous obtenons : P> [[ 0. 37.4 0. 0. 0. 16.7 23.8 22.1]
[ 0. 0. 100. 0. 0. 0. 0. 0. ]
[ 0. 0. 0. 100. 0. 0. 0. 0. ]
[ 0. 0. 0. 0. 100. 0. 0. 0. ]
[ 1.7 0. 0. 0. 0. 83.3 11.9 3. ]
[ 9. 7.4 0. 0. 0. 0. 64.2 19.4]
[ 26.7 17.9 0. 0. 0. 0. 0. 55.5]
[ 62.6 37.4 0. 0. 0. 0. 0. 0. ]]
Intéressant, mais le comportement de ma solution dépend fortement de Ordonnance Coefficient. En fait, si vous le faites négatif, il commence à avoir une propension à inverser les données, tandis que si elle est nulle, les résultats seront indiscernables d'un aléatoire. En d'autres termes, vous pouvez accorder l'algorithme à n'importe quel degré de désordre que vous souhaitez relativement aux positions de départ.
Cette propriété d'avoir au hasard tout en maintenant une propension de commande le rend amusant à utiliser pour les algorithmes de tri des analyses de base où vous souhaitez étudier l'impact de l'ordre, de l'ordre inverse ou du caractère aléatoire sur l'efficacité du tri.
@PJS a changé le code pour créer votre ordre de commande plus explicite. Notez que d'autres distributions pourraient également être intéressantes. par exemple. Cauchy mettrait parfois des éléments très loin, ce qui pourrait être utile / intéressant
J'en doute, cela semble être une chose assez inhabituelle à faire.
Je ne pense pas que le module aléatoire a un concept de légèrement aléatoire.