Объединение двух и более массивов в один массив по цифровым ключам без дублирования в подмассивах

Я думаю, вам просто нужна комбинация array_merge и array_unique (поскольку я отмечаю, что у вас нет дубликатов в ваших листовых массивах):

$megaArray = [];

foreach ($arrays as $subArray) {
  foreach ($subArray as $key => $value) {
    if (array_key_exists($key, $megaArray)) {
      $megaArray[$key] = array_unique(array_merge($megaArray[$key], $value));
    } else {
      $megaArray[$key] = $value;
    }
  }
}

Судя по ожидаемому результату, вам нужно одновременно проверить ключ и значения. Я пишу код, который создает точный выходной массив, подобный вашему образцу. Нет нужды говорить, что с помощью функции можно упростить весь процесс, но для понимания принципа ситуации я каждый раз повторяю foreach.

$newarray = array();

//-------------
$array1 = array();
$array1[77][0] = 'Bold Condensed';
$array1[77][1] = 'Bold Condensed 2';
$array1[77][2] = 'Bold Condensed 3';

foreach($array1 as $key => $value) {
    if (array_key_exists($key, $newarray)) {
        foreach($value as $subkey => $subvalue) {
            if (!array_key_exists($subkey, $newarray[$key])) {
                $newarray[$key][$subkey] = $subvalue;
            } elseif (array_key_exists($subkey, $newarray[$key]) and $subvalue != $newarray[$key][$subkey]) {
                $newkey = count($newarray[$key]);
                $newarray[$key][$newkey] = $subvalue;
            }
        }
    } else {
        $newarray[$key] = $value;
    }
}

//-------------
$array2 = array();
$array2[77][0] = 'Bold Condensed';
$array2[136][0] = 'Regular';

foreach($array2 as $key => $value) {
    if (array_key_exists($key, $newarray)) {
        foreach($value as $subkey => $subvalue) {
            if (!array_key_exists($subkey, $newarray[$key])) {
                $newarray[$key][$subkey] = $subvalue;
            } elseif (array_key_exists($subkey, $newarray[$key]) and $subvalue != $newarray[$key][$subkey]) {
                $newkey = count($newarray[$key]);
                $newarray[$key][$newkey] = $subvalue;
            }
        }
    } else {
        $newarray[$key] = $value;
    }
}

//-------------
$array3 = array();
$array3[77][0] = 'Bold Condensed (1, 2, 3)';
$array3[168][0] = 'Regular';
$array3[168][1] = 'Bold';

foreach($array3 as $key => $value) {
    if (array_key_exists($key, $newarray)) {
        foreach($value as $subkey => $subvalue) {
            if (!array_key_exists($subkey, $newarray[$key])) {
                $newarray[$key][$subkey] = $subvalue;
            } elseif (array_key_exists($subkey, $newarray[$key]) and $subvalue != $newarray[$key][$subkey]) {
                $newkey = count($newarray[$key]);
                $newarray[$key][$newkey] = $subvalue;
            }
        }
    } else {
        $newarray[$key] = $value;
    }
}

//Final result
print('<pre>'.print_r($newarray, true).'</pre>');

array_merge_recursive не требуется, поскольку для каждого идентификатора существует только 1 уровень, и ваш array_key_exists всегда будет истинным, поскольку вы получаете один и тот же ключ из foreach и проверяете один и тот же массив.

Вы можете сразу получить значения на основе id (в вашем случае это 77 и т. д.) и продолжать объединять значения. Позже вы сможете array_unique использовать их только один раз для повышения эффективности и получать только уникальные значения для каждого идентификатора.

<?php

$result = [];

foreach($d as $subs){
    foreach($subs as $id => $values){
        $result[ $id ] = array_merge($result[ $id ] ?? [], $values);
    }
}

$result = array_map(fn($v) => array_unique($v), $result);

print_r($result);

Живая демо

foreach ($arrays as $array) {
  foreach ($array as $key => $values) {
    $result[$key] = array_unique(array_merge($result[$key] ?? [], ...[ $values ]));
  }
}

вот код

  <?php
    
    
    // Given arrays
    $array1 = [
        77 => ['Bold Condensed', 'Bold Condensed 2', 'Bold Condensed 3'],
    ];
    
    $array2 = [
        77 => ['Bold Condensed'],
        136 => ['Regular'],
    ];
    
    $array3 = [
        77 => ['Bold Condensed (1, 2, 3)'],
        168 => ['Regular', 'Bold'],
    ];
    
    // Function to merge arrays
    function mergeArrays(...$arrays)
    {
        $result = [];
    
        foreach ($arrays as $array) {
            foreach ($array as $key => $values) {
                if (!isset($result[$key])) {
                    $result[$key] = $values;
                } else {
                    // Merge values, removing duplicates
                    $result[$key] = array_values(array_unique(array_merge($result[$key], $values)));
                }
            }
        }
    
        return $result;
    }
    
    // Merge the arrays
    $mergedArray = mergeArrays($array1, $array2, $array3);
    
    // Output the merged array
    print_r($mergedArray);
    
    ?>

Функция mergeArrays принимает несколько массивов в качестве аргументов и объединяет их в один массив результатов. Он перебирает каждый массив, объединяя значения для каждого ключа и удаляя дубликаты.

Чтобы избежать более дорогостоящих вызовов array_merge() и array_unique() на каждой итерации вложенного цикла, поддерживайте временный массив поиска и помещайте в массив результатов только уникальные значения. Другими словами, не создавайте беспорядок в коде, чтобы потом его можно было навести порядок.

Код: (Демо)

$result = [];
foreach ($arrays as $set) {
    foreach ($set as $id => $row) {
        foreach ($row as $value) {
            if (!isset($lookup[$id][$value])) {
                $lookup[$id][$value] = $value;
                $result[$id][] = $value;
            }
        }
    }
}
var_export($result);

Выход:

array (
  77 => 
  array (
    0 => 'Bold Condensed',
    1 => 'Bold Condensed 2',
    2 => 'Bold Condensed 3',
    3 => 'Bold Condensed (1, 2, 3)',
  ),
  136 => 
  array (
    0 => 'Regular',
  ),
  168 => 
  array (
    0 => 'Regular',
    1 => 'Bold',
  ),
)