Распределение бина не назначает правильные суммы

Question

У меня есть массив, который может содержать от 4 до 4000 записей, я должен равномерно распределить суммы по 4 людям. Я изо всех сил пытаюсь заставить мой код работать так, как мне нужно.

Как вы можете видеть, мое выделение для массивов не так, как нужно.

Array ( [0] => Array ( [0] => 80 [7] => 40 [8] => 50 ) 
        [1] => Array ( [1] => 80 ) 
        [2] => Array ( [2] => 70 [6] => 30 )
        [3] => Array ( [3] => 60 [5] => 40 )  
      )

• массив 0 имеет всегоиз 150
• массив 1 имеет в общей сложности 80
• массив 2 имеет в общей сложности 100
• массив 3 имеет в общей сложности 100

код:

<?php
arrayBuilder();
function arrayBuilder()
{
    $list_of_items = [80, 20, 30, 40, 50, 60, 70, 80];
    rsort($list_of_items);
    $number_of_cont = 4;
    $weight_of_items = array_sum($list_of_items);
    $weight_per_cont = ($weight_of_items/$number_of_cont);
    $containers = [];
    $sumArray = $newArray = [];
    $containersSorted = buildArray($list_of_items,$number_of_cont,$containers,$weight_per_cont);
    $itemsNotAdded = itemsNotINArray($list_of_items, $containersSorted);
    foreach ($containersSorted as $k => $subArray) {
        foreach ($subArray as $id => $value) {
            if(isset($sumArray[$k])) {
                $sumArray[$k] += $value;
            }else{
                $sumArray[$k] = $value;
            }
        }
    }
    sort($sumArray);
    $itemsNotAdded = array_values($itemsNotAdded);
    foreach($itemsNotAdded as $key => $value){
        foreach($sumArray as $minkey => $minval){
            if($minkey == $key) {
                $containersSorted[$key][] = $value;
                unset($itemsNotAdded[$key]);
            }
        }
    }

    print_r($containersSorted);
};

function itemsNotINArray($list_of_items, $containersSorted){
    foreach($containersSorted as $conid => $conval){
        foreach($list_of_items as $key => $value){
            if(key_exists($key,$conval)){
               unset($list_of_items[$key]);
               continue;
            }
        }
    }
    return $list_of_items;
};

  function getMisMatchKey($itemsNotAdded, $containersSorted){

  }

  function buildArray($list_of_items,$number_of_cont,$containers, 
  $weight_per_cont){
    foreach($list_of_items as $key => $item) {
        for ($i = 0; $i < $number_of_cont; $i++) {
            $total = (isset($containers[$i])) ? array_sum($containers[$i]) : 0;
            if (($total + $item) < $weight_per_cont) {
                $containers[$i][$key] = $item;
                break;
            }
        }
    }
    return $containers;

};
?>

Должно было работать равномерно

Array ( [0] =>  Array ( [0] => 80 [7] => 20 ) 
        [1] => Array ( [1] =>  80 [6] => 30 ) 
        [2] => Array ( [2] => 70 [8] => 40 )  
        [3] => Array ( [3] => 60 [5] => 50 )
      )

Answer 1

Это разбивает массив на массивы с парами значения 80:

public function action_binAllocation()
{
    $list_of_items = [80, 20, 30, 40, 50, 60, 70, 80, 10, 70];
    $sum = 80;
    $evenlySortedArray = $this->findPairsInArrayWhereSum($sum, $list_of_items);
    print_r($evenlySortedArray);
}

public function findPairsInArrayWhereSum($sum, $arr = [])
{
    $s = [];
    $evenlyDistributedArrays = [];
    for ($i = 0; $i < count($arr); $i++) {
        $temp = $sum - $arr[$i];
        $s[] = $arr[$i];
        if (in_array($temp, $s)) {
            $evenlyDistributedArray[] = [$arr[$i], $temp];
        }
    }
    return $evenlyDistributedArray;
}