J'ai le tableau suivant: résultat:
10 Réponses :
function get_keys_for_duplicate_values($my_arr, $clean = false) {
if ($clean) {
return array_unique($my_arr);
}
$dups = $new_arr = array();
foreach ($my_arr as $key => $val) {
if (!isset($new_arr[$val])) {
$new_arr[$val] = $key;
} else {
if (isset($dups[$val])) {
$dups[$val][] = $key;
} else {
$dups[$val] = array($key);
// Comment out the previous line, and uncomment the following line to
// include the initial key in the dups array.
// $dups[$val] = array($new_arr[$val], $key);
}
}
}
return $dups;
}
obviously the function name is a bit long;)Now $dups will contain a multidimensional array keyed by the duplicate value, containing each key that was a duplicate, and if you send "true" as your second argument it will return the original array without the duplicate values.Alternately you could pass the original array as a reference and it would adjust it accordingly while returning your duplicate array
Vous pouvez raccourcir le chemin du code lorsque $ Clean === true en mettant si ($ propre === true) {retour array_unique ($ my_arr); } en haut;)
À propos, la méthode la plus rapide que j'ai testée jusqu'à présent, gère 100 itérations d'un réseau de 100 000 éléments plus de 0,04463 secondes par itération!
Modifié mon méthodologie de test un peu et tout en restant la plus rapide, le temps d'itération réel est plus proche de 0,1811 secondes; Le tableau avait (en moyenne) 165 000 éléments, dont 100 000 étaient uniques.
Peut-être que ce n'était pas l'intention de la fonction, mais cette fonction renvoie également des valeurs non-dupliquées. Je voulais juste mentionner cela. J'ai fait un foreach ($ DUPS comme $ k => $ v) {si ($ ($ v) == 1) non défini ($ DUPS [$ K]); } pour résoudre ce problème mais je pense que cela n'est pas très efficace.
Oups, il y avait un problème logique, il aurait dû être si (! Isset ($ new_arr [$ val])) , je l'ai réparé et cela devrait fonctionner comme prévu maintenant
Peut-être que c'est intentionnel, mais cette fonction ne renvoie pas toutes les clés qui ont des valeurs en double. Il ne renvoie que les clés après le premier trouvé. Je vois comment cela pourrait être intentionnel (vous ne pouvez considérer que les derniers «duplicats»), mais cela me confondait. Je m'attendais à ce que cela retourne Toutes les clés valeurs que d'autres clés avaient également eu.
@goron qui a été l'intention, mais je vois certainement comment il serait utile d'avoir l'une des deux options. J'ai donc mis à jour un commentaire à faire en sorte que cette fonction soit essentiellement comme prévu.
@Trey merci beaucoup! Tu as fait ma journée.
array(1) {
[0]=>
int(1)
}
voici un code mec keys_of_of_dupliqué est maintenant le tableau contenant les touches de baies dupliquées;) au revoir
Dans mes tests, cette fois-ci (60 secondes) sur un tableau suffisamment grand (100 000 dans mon test).
Je vais d'abord répondre à la deuxième question. Vous souhaitez utiliser array_keys code> avec "Search_value" spécifié.
// $duplicates
Array
(
[1] => a
)
// $result
Array
(
[2] => b
[3] => c
[4] => d
)
// $unique_keys
Array
(
[0] => 2
[1] => 3
[2] => 4
)
// $duplicate_keys
Array
(
[0] => 0
[1] => 1
)
Cela reviendra des valeurs et non des clés.
@CYPHER - Tu as raison. J'ai oublié d'inclure array_keys . J'ai mis à jour ma réponse.
En outre, une question intéressante serait s'il souhaitait imprimer toutes les touches dupliquées - dans votre cas 0 et 1 pour A
@CYPHER - Un simple Array_Keys (Array_Intersect ($ TRAY, $ DUPLICATES)) ferait exactement cela. :)
+1 belle réponse. J'aime l'approche unique / diff. Mais OP n'a demandé pas pour l'unique, mais ces clés qui ne sont pas uniques. Donc, vous devriez probablement non seulement mettre cela en commentaire mais également dans votre réponse.
Ceci n'est vraiment utile que sur de petites tableaux - plus le tableau est grand, plus cela itération à plusieurs reprises et que ces comparaisons vont faire mal. Vraiment vite pour les petits ensembles assez petits, bien que =)
Dans le cas où vous souhaitez connaître également le nombre de "paires" dans les doublons que vous pouvez également utiliser compter (array_unique ($ Duplicatats)); Donc, si vous dupliquez une matrice était ("A", "B", "A", "B") Cela reviendrait 2
print_r(getDupKeys($array, false, false));
Array
(
[0] => 2
[1] => 4
[2] => 6
[3] => 8
[4] => 10
[5] => 12
[6] => 15
[7] => 17
[8] => 19
[9] => 21
[10] => 23
[11] => 25
[12] => 27
[13] => 29
[14] => 31
)
J'aime beaucoup François Réponse, voici quelque chose que je suis venu avec cette conservation des clés. Je répondrai à la première question:
# original array
array(3) {
[0]=>
string(10) "2011-06-21"
[1]=>
string(10) "2011-06-22"
[2]=>
string(10) "2011-06-22"
}
# hash (filtered)
array(1) {
["2011-06-22"]=>
array(2) {
[0]=>
int(1)
[1]=>
int(2)
}
}
# the keys
array(2) {
[0]=>
int(1)
[1]=>
int(2)
}
J'ai eu un problème similaire que la question n ° 1 de l'OP. Tout ce dont j'avais besoin, ce sont les clés des valeurs dupliquées dans mon tableau d'origine. Voici ce que je suis venu avec: et pour la sortie:
function getDuplicateValueKeys($my_arr, $clean = false)
{
if ($clean) {
return array_unique($my_arr);
}
$dups = array();
$new_arr = array();
$dup_vals = array();
foreach ($my_arr as $key => $value) {
if (!isset($new_arr[$value])) {
$new_arr[$value] = $key;
} else {
array_push($dup_vals,$value);
}
}
foreach ($my_arr as $key => $value) {
if (in_array($value, $dup_vals)) {
if (!isset($dups[$value])) {
$dups[$value]=array($key);
}else{
array_push($dups[$value],$key);
}
}
}
return $dups;
}
Un autre exemple: sortie:
Voici une autre solution pour la question 1 que j'ai l'habitude d'obtenir des doublons dans un tableau unidimensionnel:
Prenant par exemple ce tableau: P>
[
[
0,
4,
5,
],
[
1,
6,
],
[
2,
7,
8,
],
]