Devolver solo entradas duplicadas de una matriz (sin distinción entre mayúsculas y minúsculas)

Quiero recuperar todas las entradas duplicadas que no distinguen entre mayúsculas y minúsculas de una matriz. ¿Es esto posible en PHP?

array(
    1 => '1233',
    2 => '12334',
    3 => 'Hello',
    4 => 'hello',
    5 => 'U'
);

Matriz de salida deseada:

array(
    1 => 'Hello',
    2 => 'hello'
);

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

<?php
function array_not_unique($raw_array) {
    $dupes = array();
    natcasesort($raw_array);
    reset($raw_array);

    $old_key   = NULL;
    $old_value = NULL;
    foreach ($raw_array as $key => $value) {
        if ($value === NULL) { continue; }
        if (strcasecmp($old_value, $value) === 0) {
            $dupes[$old_key] = $old_value;
            $dupes[$key]     = $value;
        }
        $old_value = $value;
        $old_key   = $key;
    }
    return $dupes;
}

$raw_array    = array();
$raw_array[1] = 'abc@xyz.com';
$raw_array[2] = 'def@xyz.com';
$raw_array[3] = 'ghi@xyz.com';
$raw_array[4] = 'abc@xyz.com'; // Duplicate

$common_stuff = array_not_unique($raw_array);
var_dump($common_stuff);

Deberá hacer que su función no distinga entre mayúsculas y minúsculas para obtener el resultado “Hola” => “hola” que está buscando, pruebe este método:

$arr = array(1=>'1233',2=>'12334',3 =>'Hello' ,4=>'hello', 5=>'U');

// Convert every value to uppercase, and remove duplicate values
$withoutDuplicates = array_unique(array_map("strtoupper", $arr));

// The difference in the original array, and the $withoutDuplicates array
// will be the duplicate values
$duplicates = array_diff($arr, $withoutDuplicates);
print_r($duplicates);

La salida es:

Array
(
[3] => Hello
[4] => hello
)

Editado por @AlixAxel:

Esta respuesta es muy engañosa. Solo funciona en esta condición específica. Este contraejemplo:

$arr = array(1=>'1233',2=>'12334',3 =>'Hello' ,4=>'HELLO', 5=>'U');

falla miserablemente. Además, esta no es la forma de mantener duplicados:

array_diff($arr, array_unique($arr));

Dado que uno de los valores duplicados estará en array_uniquey luego cortado por array_diff.

Editado por @RyanDay:

Así que mire la respuesta de @ Srikanth o @ Bucabay, que funcionan para todos los casos (busque mayúsculas y minúsculas en Bucabay), no solo los datos de prueba especificados en la pregunta.

Esta es la forma correcta de hacerlo (distingue entre mayúsculas y minúsculas):

array_intersect($arr, array_unique(array_diff_key($arr, array_unique($arr))));

Y una solución que no distingue entre mayúsculas y minúsculas:

$iArr = array_map('strtolower', $arr);
$iArr = array_intersect($iArr, array_unique(array_diff_key($iArr, array_unique($iArr))));

array_intersect_key($arr, $iArr);

Pero la respuesta de @Srikanth es más eficiente (en realidad, es la única que funciona correctamente además de este).

function array_not_unique($raw_array) {
    $dupes = array();
    natcasesort($raw_array);
    reset($raw_array);

    $old_key   = NULL;
    $old_value = NULL;
    foreach ($raw_array as $key => $value) {
        if ($value === NULL) { continue; }
        if (strcasecmp($old_value, $value) === 0) {
            $dupes[$old_key] = $old_value;
            $dupes[$key]     = $value;
        }
        $old_value = $value;
        $old_key   = $key;
    } return $dupes;
}

Lo que Srikanth (john) agregó pero con la comparación sin distinción entre mayúsculas y minúsculas.

Probar:

$arr2 = array_diff_key($arr, array_unique($arr));

mayúsculas y minúsculas:

array_diff_key($arr, array_unique(array_map('strtolower', $arr)));

La publicación de 12 años y la respuesta aceptada devuelve una matriz en blanco y otras son largas.

Aquí está mi opinión para los futuros Googlers que es breve y devuelve TODOS los índices duplicados (¿índices?).

$myArray = array('fantastic', 'brilliant', 'happy', 'fantastic', 'Happy', 'wow', 'battlefield2042 :(');

function findAllDuplicates(array $array)
{
    // Remove this line if you do not need case sensitive.
    $array = array_map('strtolower', $array);

    // Remove ALL duplicates
    $removedDuplicates = array_diff($array, array_diff_assoc($array, array_unique($array)));

    return array_keys(array_diff($array, $removedDuplicates));
    // Output all keys with duplicates
    // array(4) {
    //   [0]=>int(0)
    //   [1]=>int(2)
    //   [2]=>int(3)
    //   [3]=>int(4)
    // }


    return array_diff($array, $removedDuplicates);
    // Output all duplicates
    // array(4) {
    //   [0]=>string(9) "fantastic"
    //   [2]=>string(5) "happy"
    //   [3]=>string(9) "fantastic"
    //   [4]=>string(5) "happy"
    // }
}