En Python, mélanger une séquence de nombres a toujours été un utilitaire utile et une question qui est également apparue dans de nombreux entretiens de placement en entreprise. Connaître plusieurs méthodes pour y parvenir peut toujours être un plus. Discutons de certaines façons d’y parvenir.
Python Mélange aléatoire une liste
Dans Python, il existe plusieurs façons de mélanger une liste. Voici différentes méthodes Python pour mélanger les listes.
- Utilisation de sorted()
- Utiliser random.shuffle()
- Utiliser random.sample()
- Utiliser la méthode de sélection aléatoire
- Utilisation de l'algorithme de lecture aléatoire de Fisher-Yates
- Utilisation de la fonction itertools.permutations()
- Utiliser NumPy
Mélangez aléatoirement une liste en utilisant sorted()
Une version triée de la liste peut être produite à l'aide du trié() fonction. Nous mélangeons efficacement les éléments de manière aléatoire en les utilisant sur une copie de la liste qui a été mélangée.
Python3
import> random> my_list>=> [>1>,>2>,>3>,>4>,>5>]> shuffled_list>=> sorted>(my_list, key>=>lambda> x: random.random())> print>(>'Original list:'>, my_list)> print>(>'Shuffled list:'>, shuffled_list)> |
>
>
Sortir
Original list: [1, 2, 3, 4, 5] Shuffled list: [2, 3, 4, 5, 1]>
Complexité temporelle : O(nlogn), où n est la longueur de la liste
Complexité spatiale : O(n), où n est la longueur de la liste
Randomiser une liste à l'aide de Random.Shuffle()
Aléatoire.Shuffle() est la méthode la plus recommandée pour mélanger une liste. Python dans sa bibliothèque aléatoire fournit cette fonction intégrée qui mélange la liste sur place. L’inconvénient est que l’ordre des listes est perdu dans ce processus. Utile pour les développeurs qui choisissent de gagner du temps et de se dépêcher.
Python3
java comment remplacer
import> random> test_list>=> [>1>,>4>,>5>,>6>,>3>]> print>(>'The original list is : '> +> str>(test_list))> # using random.shuffle() to shuffle a list> random.shuffle(test_list)> print>(>'The shuffled list is : '> +> str>(test_list))> |
>
>
Sortir
The original list is : [1, 4, 5, 6, 3] The shuffled list is : [5, 1, 3, 4, 6]>
Complexité temporelle : O(n), où n est la longueur de la liste
Complexité spatiale : O(n), où n est la longueur de la liste
Randomisez une liste u chanter Random.Sample()
Échantillon aléatoire(), Il s'agit d'une fonction très utile, meilleure que la méthode shuffle utilisée ci-dessus dans la mesure où elle crée une nouvelle liste mélangée et la renvoie plutôt que de perturber l'ordre de la liste d'origine. Ceci est utile dans les cas où nous devons conserver la liste d'origine.
Python3
changer de programmation Java
import> random> test_list>=> [>1>,>4>,>5>,>6>,>3>]> print>(>'The original list is : '> +> str>(test_list))> # using random.sample()to shuffle a list> res>=> random.sample(test_list,>len>(test_list))> print>(>'The shuffled list is : '> +> str>(res))> |
>
>
Sortir
The original list is : [1, 4, 5, 6, 3] The shuffled list is : [4, 3, 1, 6, 5]>
Complexité temporelle : O(n), où n est la longueur de la liste
Complexité spatiale : O(n), où n est la longueur de la liste
Randomiser une liste à l'aide de la méthode de sélection aléatoire
Dans cette méthode, nous allons randomiser une liste en utilisant méthode de sélection aléatoire . Nous sélectionnons un index au hasard et ajoutons cet élément à cet index à la liste.
Python3
sous-chaîne de chaîne java
import> random> arr>=> [>1>,>2>,>3>,>4>,>5>,>6>]> print>(>'Original List: '>, arr)> n>=> len>(arr)> for> i>in> range>(n):> >j>=> random.randint(>0>, n>->1>)> >element>=> arr.pop(j)> >arr.append(element)> > print>(>'Shuffled List: '>, arr)> |
>
>
Sortir
Original List: [1, 2, 3, 4, 5, 6] Shuffled List: [1, 5, 2, 6, 3, 4]>
Complexité temporelle : O(n) où n est la longueur de la liste
Complexité spatiale : O(1)
Mélangez aléatoirement une liste à l'aide de l'algorithme de lecture aléatoire de Fisher-Yates
C'est l'un des célèbres algorithmes Algorithme de lecture aléatoire de Fisher-Yates , principalement utilisé pour mélanger une séquence de nombres en Python. Cet algorithme prend simplement la valeur d'index la plus élevée et l'échange avec la valeur actuelle, ce processus se répète en boucle jusqu'à la fin de la liste.
Python3
import> random> test_list>=> [>1>,>4>,>5>,>6>,>3>]> print>(>'The original list is : '> +> str>(test_list))> # using Fisher–Yates shuffle Algorithm to shuffle a list> for> i>in> range>(>len>(test_list)>->1>,>0>,>->1>):> ># Pick a random index from 0 to i> >j>=> random.randint(>0>, i>+> 1>)> ># Swap arr[i] with the element at random index> >test_list[i], test_list[j]>=> test_list[j], test_list[i]> print>(>'The shuffled list is : '> +> str>(test_list))> |
>
trier une liste de tableaux
>
Sortir
The original list is : [1, 4, 5, 6, 3]The shuffled list is : [3, 4, 5, 6, 1]>
Complexité temporelle : O(n), où n est la longueur de la liste
Complexité spatiale : O(n), où n est la longueur de la liste
Randomiser une liste à l'aide de la fonction Itertools.Permutations()
Cette méthode génère toutes les permutations possibles de la liste originale en utilisant le itertools.permutations() fonction, puis sélectionnez-en une au hasard.
Python3
import> random> import> itertools> lst>=> [>1>,>4>,>5>,>6>,>3>]> permutations>=> list>(itertools.permutations(lst))> shuffled_lst>=> random.choice(permutations)> print>(>'Shuffled list:'>, shuffled_lst)> |
>
>
Sortir
Shuffled list: (6, 5, 4, 1, 3)>
Complexité temporelle : O(n!) où n est la longueur de la liste, en raison de la génération de toutes les permutations possibles.
Complexité spatiale : O(n!) car toutes les permutations possibles sont générées et stockées dans une liste.
Randomiser une liste utiliser Numpy
Nous utilisons NumPy() pour mélanger les éléments de la liste. Pour randomiser une liste à l'aide de numpy, nous devons convertir la liste en tableau NumPy, puis appliquer la fonction de réduction et elle renvoie la liste mélangée et imprime la liste mélangée.
Python3
import> numpy as np> from> functools>import> reduce> test_list>=> [>1>,>4>,>5>,>6>,>3>]> # Printing original list> print>(>'The original list is : '> +> str>(test_list))> # using reduce() and numpy to shuffle a list> res>=> reduce>(>lambda> acc, _: np.random.permutation(acc),> >range>(>len>(test_list)), np.array(test_list))> print>(>'The shuffled list is : '> +> str>(res.tolist()))> |
gestion des exceptions java
>
>
Sortir
The original list is : [1, 4, 5, 6, 3] The shuffled list is : [3, 6, 1, 5, 4]>
Complexité temporelle : La complexité temporelle de la fonction réduire() dépend du nombre d'itérations, qui est égal à la longueur de la liste. La complexité temporelle de np.random.permutation() est O(n) où n est la longueur du tableau d'entrée. Par conséquent, la complexité temporelle de ce code est O(n^2).
Complexité spatiale : La complexité spatiale de ce code dépend de la taille de la liste. La liste est stockée en mémoire avec quelques variables supplémentaires utilisées par la fonction réduire(). Par conséquent, la complexité spatiale est O(n).