Français
Français
La fonction STR_SHUXH dans PHP est souvent utilisée pour perturber aléatoirement la séquence des chaînes et générer diverses permutations aléatoires. Il est très simple à utiliser, comme:
<?php
$original = "abcdef";
$shuffled = str_shuffle($original);
echo $shuffled;
?>
Chaque fois que ce code est exécuté, il renvoie une combinaison de permutation aléatoire de la chaîne d'origine. Cependant, dans certains scénarios d'application, nous voulons que les combinaisons aléatoires générées ne soient pas répétées, telles que la génération de codes de vérification, les mots de passe aléatoires, les séquences de loterie, etc.
Cependant, en raison de la nature aléatoire de STR_SHUXE , il est toujours possible de produire la même permutation à chaque appel, en particulier lorsque la taille de l'échantillon est petite ou que le nombre d'appels est important, la probabilité de duplication augmente considérablement. Alors, comment éviter de générer des combinaisons de caractères en double? Voici quelques stratégies pratiques.
La méthode la plus intuitive consiste à générer une nouvelle chaîne aléatoire et à la stocker dans un tableau ou une collection. Lorsque vous générez une nouvelle chaîne, vérifiez s'il existe déjà et régénérez-le s'il existe.
<?php
$original = "abcdef";
$generated = [];
function generateUniqueShuffle($str, &$history) {
do {
$shuffled = str_shuffle($str);
} while (in_array($shuffled, $history));
$history[] = $shuffled;
return $shuffled;
}
// Exemple：générer10Une combinaison aléatoire unique
for ($i = 0; $i < 10; $i++) {
echo generateUniqueShuffle($original, $generated) . "\n";
}
?>
Cette méthode est simple, mais à mesure que le nombre de générations augmente, la vérification de la duplication deviendra plus lente et pourrait éventuellement générer moins que le nombre souhaité (combinaisons limitées).
Toutes les permutations de chaînes sont limitées (les chaînes de longueur n ont n! Permutations). Vous pouvez d'abord utiliser un algorithme récursif pour générer toutes les permutations, les stocker, puis les extraire et les dédupliquer.
L'exemple génère un code de base entièrement arché:
<?php
function permute($str, $prefix = '') {
$result = [];
$len = strlen($str);
if ($len == 0) {
$result[] = $prefix;
} else {
for ($i = 0; $i < $len; $i++) {
$rem = substr($str, 0, $i) . substr($str, $i + 1);
$result = array_merge($result, permute($rem, $prefix . $str[$i]));
}
}
return $result;
}
$original = "abc";
$allPermutations = permute($original);
shuffle($allPermutations); // Ordre de perturbation aléatoire
foreach ($allPermutations as $perm) {
echo $perm . "\n";
}
?>
Cette méthode convient aux courtes longueurs de chaîne (généralement moins de 8), car le nombre de permutations complètes explose (8! = 40320), qui consomme beaucoup de mémoire et de temps.
Si vous devez éviter la duplication entre les demandes ou pendant une longue période, vous pouvez enregistrer la combinaison générée dans la base de données ou le cache (telles que Redis), et vérifier si elle est dupliquée après chaque génération, puis décider de revenir.
Cette méthode est très pratique dans des environnements multi-utilisateurs ou lors de la génération de grands lots de combinaisons aléatoires, en évitant une utilisation excessive de la mémoire et en assurant l'unicité.
Exemple d'idées de pseudocode:
<?php
// Connectez-vous à la base de données，Requête si la combinaison actuelle existe déjà
// S'il y a，则重新générer，直到générer唯一组合
// Insérez la nouvelle combinaison dans la base de données pour enregistrer
?>
L'implémentation spécifique dépendra du système de base de données et des besoins commerciaux que vous utilisez.
Si vous évitez simplement la répétition simple, vous pouvez également combiner STR_SHUXE et remplacement de caractère aléatoire pour augmenter l'espace aléatoire. Par exemple, après perturbation, remplacez au hasard plusieurs des caractères des autres ensembles de caractères autorisés.
Cela réduit la probabilité de répétition, mais n'est pas garanti d'être absolument unique.
Scénarios à petite échelle et simples : enregistrez les résultats générés avec un tableau et la détection de boucle évite la duplication;
Crises de taille moyenne et courtes : permutations complètes pré-générées, dessinées au hasard;
Unité unicité à grande échelle et persistant : utilisez des bases de données ou des caches pour déduir les enregistrements;
Randomment amélioré : combiné avec d'autres méthodes de transformation aléatoires, réduisent la probabilité de répétition.
Lorsque vous choisissez une stratégie, vous devez peser la longueur de la chaîne, le nombre de générations, les performances et l'utilisation de la mémoire et concevoir une solution raisonnable.
