php: comprueba si una matriz tiene duplicados

Question

Estoy seguro de que esta es una pregunta extremadamente obvia, y que hay una función que hace exactamente esto, pero parece que no puedo encontrarlo. En PHP, me gustaría saber si mi matriz tiene duplicados, lo más eficientemente posible. No quiero eliminarlos como array_unique, y no quiero particularmente ejecutar array_unique y compararlo con la matriz original para ver si son iguales, ya que esto parece muy ineficiente. En lo que respecta al rendimiento, la "condición esperada" es que la matriz no tenga duplicados.

sólo me gustaría ser capaz de hacer algo como

if (no_dupes($array)) 
    // this deals with arrays without duplicates 
else 
    // this deals with arrays with duplicates 

¿Hay alguna función obvia que no estoy pensando?
How to detect duplicate values in PHP array?
tiene el título correcto, y es una pregunta muy similar, sin embargo, si realmente lees la pregunta, está buscando los valores de la cuenta de la matriz.

Answer 1

que puede hacer:

function has_dupes($array) { 
    $dupe_array = array(); 
    foreach ($array as $val) { 
     if (++$dupe_array[$val] > 1) { 
      return true; 
     } 
    } 
    return false; 
} 

Answer 2

dos maneras de hacerlo de manera eficiente que se me ocurre:

1. insertar todos los valores en una especie de tabla hash y comprobar si el valor que está insertando ya está en ella (O esperado (n) tiempo y o (n) el espacio)

2. la clasificación de la matriz y a continuación, comprobar si las células adyacentes son iguales (o (nlogn tiempo) y o (1) o o (n) el espacio en función del algoritmo de clasificación)

La solución de stormdrain probablemente sería O (n^2), al igual que cualquier solución que implique escanear el conjunto para cada elemento que busque un duplicado

Answer 3

Sé que no está interesado en array_unique(). Sin embargo, no encontrará una función mágicaobvia ni escribir una será más rápido que hacer uso de las funciones nativas.

propongo:

function array_has_dupes($array) { 
    // streamline per @Felix 
    return count($array) !== count(array_unique($array)); 
} 

Ajuste el segundo parámetro de array_unique() para satisfacer sus necesidades de comparación.

Answer 4

Como dijimos específicamente que no desea utilizar array_unique Voy a ignorar las otras respuestas a pesar del hecho de que son probablemente mejor.

¿Por qué no usa array_count_values() y luego verifica si la matriz resultante tiene algún valor mayor que 1?

Answer 5

¡Manténgalo simple, tonto! ;)

simple lógica OR ...

function checkDuplicatesInArray($array){ 
    $duplicates=FALSE; 
    foreach($array as $k=>$i){ 
     if(!isset($value_{$i})){ 
      $value_{$i}=TRUE; 
     } 
     else{ 
      $duplicates|=TRUE;   
     } 
    } 
    return ($duplicates); 
} 

Saludos!

Answer 6

Encontrar esta solución útil

function get_duplicates($array) { 
    return array_unique(array_diff_assoc($array, array_unique($array))); 
} 

Después de eso resultado de la cuenta si es mayor que 0 que duplicados otra cosa única.

Answer 7

Aquí está mi opinión sobre esto ... después de una evaluación comparativa, encontré que este es el método más rápido para esto.

function has_duplicates($array) { 
    return count(array_keys(array_flip($array))) !== count($array); 
} 

... o según las circunstancias esto podría ser marginalmente más rápido.

function has_duplicates($array) { 
    $array = array_count_values($array); 
    rsort($array); 
    return $array[0] > 1; 
} 

Answer 8

PHP tiene una función para contar las apariciones de la matriz http://www.php.net/manual/en/function.array-count-values.php

Answer 9

estoy usando esto:

if(count($array)==count(array_count_values($array))){ 
    echo("all values are unique"); 
}else{ 
    echo("there's dupe values"); 
} 

no sé si es el más rápido, pero funciona bastante bien por lo ahora

Answer 10

Puede hacerlo así también: Esto devolverá true si es único else devuelve falso.

$nofollow = (count($modelIdArr) !== count(array_unique($modelIdArr))) ? true : false; 

Answer 11

count($array) > count(array_unique($array)); 

Will be false si duplicados, o true si no hay duplicados.

Answer 12

SOLUCIÓN ⚡ RENDIMIENTO ⚡

Si se preocupan por el rendimiento y la micro-optimizaciones mira esto de una sola línea:

function no_dupes(array $input_array) { 
    return count($input_array) === count(array_flip($input_array)); 
} 

Descripción:

función compara el número de elementos de matriz en $input_array con array_flip elementos ed. Los valores se convierten en claves y adivinen qué: las claves deben ser únicas en las matrices asociativas, de modo que no se pierdan valores únicos y el número final de elementos sea inferior al original.

Como se ha dicho en manual claves de matriz puede ser único tipo de int o string así que esto es lo que puede tener en los valores originales de la matriz para comparar, de lo contrario comenzará a PHP casting con resultados inesperados.

PRUEBA DE REGISTROS 10M ARRAY

• Solución más votado: 14.187316179276s
• solución aceptado: 2.0736091136932s
• Esta solución respuesta: 0.14155888557434s/10

caso de prueba:

<?php 

$elements = array_merge(range(1,10000000),[1]); 

$time = microtime(true); 
accepted_solution($elements); 
echo 'Accepted solution: ', (microtime(true) - $time), 's', PHP_EOL; 

$time = microtime(true); 
most_voted_solution($elements); 
echo 'Most voted solution: ', (microtime(true) - $time), 's', PHP_EOL; 

$time = microtime(true); 
this_answer_solution($elements); 
echo 'This answer solution: ', (microtime(true) - $time), 's', PHP_EOL; 

function accepted_solution($array){ 
$dupe_array = array(); 
foreach($array as $val){ 
    // sorry, but I had to add below line to remove millions of notices 
    if(!isset($dupe_array[$val])){$dupe_array[$val]=0;} 
    if(++$dupe_array[$val] > 1){ 
    return true; 
    } 
} 
return false; 
} 

function most_voted_solution($array) { 
    return count($array) !== count(array_unique($array)); 
} 

function this_answer_solution(array $input_array) { 
    return count($input_array) === count(array_flip($input_array)); 
} 

Observe que la solución aceptada puede ser más rápida en ciertas condiciones cuando los valores no únicos están cerca del comienzo de una gran matriz.