如何在php中对数组的重复项求和

我得到了以下数组

  [0]=>
    array(7) {
        [0]=>31
        [1]=>14
        [2]=>on
        [3]=>receiver
        [4]=>pollin
        [5]=>0000-e8-de-27-176d10
        [6]=>1
    }
  [1]=>
    array(7) {
        [0]=>31
        [1]=>14
        [2]=>on
        [3]=>receiver
        [4]=>pollin
        [5]=>0000-e8-de-27-176d10
        [6]=>5
    }
  [2]=>
    array(7) {
        [0]=>0
        [1]=>17
        [2]=>"on"
        [3]=>"receiver"
        [4]=>"elro_400"
        [5]=>"0000-e8-de-27-176d10"
        [6]=>1
    }

我试图将[6]的值相加，但前提是键0-5的值相同。因此，预期的结果是：

  [0]=>
    array(7) {
        [0]=>31
        [1]=>14
        [2]=>on
        [3]=>receiver
        [4]=>pollin
        [5]=>0000-e8-de-27-176d10
        [6]=>6
    }
  [1]=>
    array(7) {
        [0]=>0
        [1]=>17
        [2]=>"on"
        [3]=>"receiver"
        [4]=>"elro_400"
        [5]=>"0000-e8-de-27-176d10"
        [6]=>1
    }

我自己尝试了

如果（array_key_存在（$vals[0]&&$vals[1]&$vals[2]&$vals[3]&$vals[4]&&$vals[5]，$res））

但是这并不像我想象的那样有效

编辑：

如果[0]-[5]是相同的，我要做的是删除重复项。但当它删除一个副本时，它应该将[6]相加

简单的例子：

  [0]=>
    array(3) {
        [0]=>31
        [1]=>14
        [2]=>1
    }
  [1]=>
    array(3) {
        [0]=>31
        [1]=>14
        [2]=>4
    }
  [2]=>
    array(3) {
        [0]=>3
        [1]=>18
        [2]=>1
    }

如果[0]和[1]相同，则可以删除重复项，但将它们相加[2]

因此，这将导致：

  [0]=>
    array(3) {
        [0]=>31
        [1]=>14
        [2]=>5
    }
  [1]=>
    array(3) {
        [0]=>3
        [1]=>18
        [2]=>1
    }

更新：正如@vonUbisch所指出的，这只会导致重复的项目。非重复项将被忽略。也许你可以解释一下你的最终目标，这个逻辑似乎真的很难理解，也许其他方法可以提供更好的解决方案

更新2:

这似乎仍然是非最优逻辑，但这就是原因

$data = array(
    array( 31, 14, 1),
    array( 31, 14, 4),
    array( 3, 18, 1)
);

$mutant = array();
$result = array();

// deconstruct the data set
foreach ($data as $key => $value){
    // use the first values as an 'id'
    $id = $value[0] . '.' . $value[1];

    // now we use that id as a key in the result array
    if (array_key_exists($id, $mutant)){
        // if the key exists (a previous dataset with same values existed), we add the last item
        $mutant[$id] += $value[2];
    }else{
        // if the key does not exist, we set the last item
        $mutant[$id] = $value[2];
    }
}

var_dump($mutant);

// array (size=2)
//  '31.14' => int 5
//  '3.18' => int 1

// now we rebuild it
foreach ($mutant as $key => $value){
    // split the key into original values
    $items = explode('.', $key);
    // depending on your data, you might need to iterate over $items here to cast them as ints
    // push the last value 
    $items[] = $value;
    // push sub array into result set
    $result[] = $items;
}

var_dump($result);
// array (size=2)
//   0 => 
//     array (size=3)
//       0 => string '31' * note that value is a string!
//       1 => string '14' (length=2)
//       2 => int 5
//   1 => 
//     array (size=3)
//       0 => string '3' (length=1)
//       1 => string '18' (length=2)
//       2 => int 1

更新：正如@vonUbisch所指出的，这只会导致重复的项目。非重复项将被忽略。也许你可以解释一下你的最终目标，这个逻辑似乎真的很难理解，也许其他方法可以提供更好的解决方案

更新2:

这似乎仍然是非最优逻辑，但这就是原因

$data = array(
    array( 31, 14, 1),
    array( 31, 14, 4),
    array( 3, 18, 1)
);

$mutant = array();
$result = array();

// deconstruct the data set
foreach ($data as $key => $value){
    // use the first values as an 'id'
    $id = $value[0] . '.' . $value[1];

    // now we use that id as a key in the result array
    if (array_key_exists($id, $mutant)){
        // if the key exists (a previous dataset with same values existed), we add the last item
        $mutant[$id] += $value[2];
    }else{
        // if the key does not exist, we set the last item
        $mutant[$id] = $value[2];
    }
}

var_dump($mutant);

// array (size=2)
//  '31.14' => int 5
//  '3.18' => int 1

// now we rebuild it
foreach ($mutant as $key => $value){
    // split the key into original values
    $items = explode('.', $key);
    // depending on your data, you might need to iterate over $items here to cast them as ints
    // push the last value 
    $items[] = $value;
    // push sub array into result set
    $result[] = $items;
}

var_dump($result);
// array (size=2)
//   0 => 
//     array (size=3)
//       0 => string '31' * note that value is a string!
//       1 => string '14' (length=2)
//       2 => int 5
//   1 => 
//     array (size=3)
//       0 => string '3' (length=1)
//       1 => string '18' (length=2)
//       2 => int 1

试一试

$array=[
...
];
$resultArray=[]；
$length=计数（$array）；
对于（$i=0；$i<$length；$i++）
{
如果（！array_key_存在（$i，$array））
{
继续；
}
$array1=$array[$i]；
$values1=array\u slice（$array1,0，-1）；
对于（$j=$i+1；$j<$length；$j++）
{
如果（！array_key_存在（$j，$array））
{
继续；
}
$array2=$array[$j]；
$values2=array\u切片（$array2，0，-1）；
如果（$values1==$values2）
{
$array1[6]+=$array2[6]；
未设置（$array[$j]）；
}
}
$resultArray[]=$array1；
}
var_dump（$resultArray）；

或

$resultArray=[]；
对于（$i=0；$i

或

$resultArray=[]；
对于（$i=0；$i

第一个解决方案应该是最快的

我还检查了

isset（$array[$I]）

的工作速度是否比

arary\u key\u exists（$I，$array）

试试看

$array=[
...
];
$resultArray=[]；
$length=计数（$array）；
对于（$i=0；$i<$length；$i++）
{
如果（！array_key_存在（$i，$array））
{
继续；
}
$array1=$array[$i]；
$values1=array\u slice（$array1,0，-1）；
对于（$j=$i+1；$j<$length；$j++）
{
如果（！array_key_存在（$j，$array））
{
继续；
}
$array2=$array[$j]；
$values2=array\u切片（$array2，0，-1）；
如果（$values1==$values2）
{
$array1[6]+=$array2[6]；
未设置（$array[$j]）；
}
}
$resultArray[]=$array1；
}
var_dump（$resultArray）；

或

$resultArray=[]；
对于（$i=0；$i

或

$resultArray=[]；
对于（$i=0；$i

第一个解决方案应该是最快的

---

我还检查了

isset（$array[$I]）

的工作速度比

arary\u key\u存在（$I，$array）

总是有一个

foreach（）

循环。我不明白key

6

的值是如何计算的。您不想将其存储在一个单独的变量中吗？总是有一个

foreach（）

loop我不明白key

6

的值是如何计算的。您不想将其存储在单独的变量中吗？您的结果将与his不匹配，请查看OP的

$data[1][6]

，但这可能完全不相关。抱歉，可能我没有正确解释它。我正在尝试将重复项合并在一起，让我的团队给出一个简单的示例。我不会在评论中使用enters，所以我在这里发布了一个例子：@Dr.B

$array = [
    ...
];

$resultArray = [];
$length = count($array);

for ($i = 0; $i < $length; $i++)
{
    if (!array_key_exists($i, $array))
    {
        continue;
    }

    $array1 = $array[$i];
    $values1 = array_slice($array1, 0, -1);

    for ($j = $i + 1; $j < $length; $j++)
    {
        if (!array_key_exists($j, $array))
        {
            continue;
        }

        $array2 = $array[$j];
        $values2 = array_slice($array2, 0, -1);

        if ($values1 == $values2)
        {
            $array1[6] += $array2[6];

            unset($array[$j]);
        }
    }

    $resultArray[] = $array1;
}

var_dump($resultArray);

$resultArray = [];

for ($i = 0; $i < count($array); $i++)
{
    $array1 = $array[$i];
    $values1 = array_slice($array1, 0, -1);

    $length = count($array);

    for ($j = $i + 1; $j < $length; $j++)
    {
        if (!array_key_exists($j, $array))
        {
            continue;
        }

        $array2 = $array[$j];
        $values2 = array_slice($array2, 0, -1);

        if ($values1 == $values2)
        {
            $array1[6] += $array2[6];

            unset($array[$j]);
        }
    }

    $array = array_values($array);

    $resultArray[] = $array1;
}

var_dump($resultArray);

$resultArray = [];

for ($i = 0; $i < count($array); $i++)
{
    $array1 = $array[$i];
    $values1 = array_slice($array1, 0, -1);

    for ($j = $i + 1; $j < count($array); $j++)
    {
        $array2 = $array[$j];
        $values2 = array_slice($array2, 0, -1);

        if ($values1 == $values2)
        {
            $array1[6] += $array2[6];

            unset($array[$j]);

            $j--;
            $array = array_values($array);
        }
    }

    $resultArray[] = $array1;
}

var_dump($resultArray);