PHP-无需考虑键的array_merge

Question

我需要有关php数组合并的帮助

我需要按值合并

所以如果我在数组1中有这样的值

 ( room room )  and in array values  ( room ) , merge will look like this =  ( room room ) 

但是如果我有

 ( room room book ) and ( book book ) merged array values will look like this  ( room room book book ) 

因此，可以说合并数组的值将是每个元素在所有数组中的最大数量，例如，

再举几个例子，（书）（书）（书）=（书）（房间书）（图书馆房间）=（图书馆房间书）（房间房间）（书书）=（房间书） （房间）（房间）（房间房间房间）=（房间房间房间）

我试过+，但是

（房间房间）（书本）是（房间房间书），那不好

我尝试了array_merge，但是

（房间）（房间）是（房间），没关系，但是（房间房间）（房间）是（房间房间房间），那是错误的。

它不依赖于顺序，键也不重要，它始终是数字（[0] [1]等）

阵列：

                [0] => Array
                    (
                        [0] => room
                        [1] => room
                    )

                [1] => Array
                    (
                        [0] => book
                        [1] => book
                        [2] => book
                        [3] => book
                    )

EXPECTED RESULT = array ( room, room, book , book , book, book )

                [0] => Array
                    (
                        [0] => room
                        [1] => room
                    )

                [1] => Array
                    (
                        [0] => room
                    )

EXPECTED RESULT = array ( room, room )

                [0] => Array
                    (
                        [0] => room
                    )

                [1] => Array
                    (
                        [0] => room


                    )

EXPECTED RESULT = array ( room )

                [0] => Array
                    (
                        [0] => room
                        [1] => room
                        [2] => book
                    )

                [1] => Array
                    (
                        [0] => room
                        [1] => book
                    )
                [2] => Array
                    (
                        [0] => room
                        [1] => room
                        [2] => room
                    )

EXPECTED RESULT = array ( room , room ,room , book )

所以它总是每个元素的最大数量，例如所有数组中的书

非常感谢你，

马雷克

Answer 1

这里是：

function user_array_merge($arr) {
  if (func_num_args() == 1) return $arr;
  $vals = array_count_values($arr);
  $arrs = func_get_args();
  array_shift($arrs);
      foreach ($arrs as $arr2) {
        $vals2 = array_count_values($arr2);
        foreach ($vals2 as $val=>$count) {
           $vals[$val] = @max( $vals[$val], $count);
        }
      }
      $result = array();
      foreach ($vals as $val=>$count) {
         $result = array_pad($result, count($result)+$count, $val);
      }
      return $result;
    }

像这样打电话

$res = user_array_merge(['room','room'], ['book', 'book','book','room'],['library']);

结果：

var_export($res);                                                                                    
array (
  0 => 'room',
  1 => 'room',
  2 => 'book',
  3 => 'book',
  4 => 'book',
  5 => 'library',
)

在大型阵列上应该相当慢。

Answer 2

这是在O（n）中执行此操作的合理方法：

function custom_array_merge() {
    // variable number of inputs
    $arrays = func_get_args();

    // consolidate into array of items => count/array(of counts) across inputs
    $counts = array_map('array_count_values', $arrays);
    $consolidated = call_user_func_array('array_merge_recursive', $counts);

    // reduce array of counts (where applicable) to maximum count
    $maximums = array_map(function($v) { 
        return is_array($v) ? max($v) : $v;
    }, $consolidated);

    // build result -- could be faster with array_fill() and concatenating 
    // but that would definitely use up more memory 
    $result = [];
    foreach ($maximums as $item => $times) {
        for ($i = 0; $i < $times; ++$i) {
            $result[] = $item;
        }
    }

    return $result;
}

看到它在行动 。