Lissage tableau de données PHP

Question

J'ai un tableau:

Array 
(
    [1] => 25 
    [2] => 50 
    [3] => 25 
) 

je voudrais en faire:

Array 
(
    [1] => 50 
    [2] => 50 
) 

Pour ce faire, je partage la valeur moyenne entre 1 et 3. Ceci est la exemple le plus simple, où la scission est 50,50. J'aimerais pouvoir ramener un tableau de 15 éléments à 6 éléments.

Des idées?

Des exemples supplémentaires [10, 15, 20, 25] réduit à deux éléments: 25 (10 + 15), 45 (20 + 25) [10, 10, 10, 10, 11] réduit à deux éléments : 25 (10 + 10 + (10/2)), 26 ((10/2) + 10 + 11)

Answer 1

Après avoir fait des tests supplémentaires sur la solution de Pierre, je l'ai remarqué ne m'a pas obtenir ce que je pensais si la réduire à la taille est un nombre impair. Voici la fonction que j'ai inventée. Il gonfle également les ensembles de données qui sont plus petits que la taille demandée.

<?php 
     function reduceto($data,$r) { 
      $c = count($data); 

      // just enough data 
      if ($c == $r) return $data; 

      // not enough data 
      if ($r > $c) { 
       $x = ceil($r/$c); 
       $temp = array(); 
       foreach ($data as $v) for($i = 0; $i < $x; $i++) $temp[] = $v; 
       $data = $temp; 
       $c = count($data); 
      } 

      // more data then needed 
      if ($c > $r) { 
       $temp = array(); 
       foreach ($data as $v) for($i = 0; $i < $r; $i++) $temp[] = $v; 
       $data = array_map('array_sum',array_chunk($temp,$c)); 
      } 
      foreach ($data as $k => $v) $data[$k] = $v/$r; 
      return $data; 
     } 
    ?> 

Answer 2

Vous pouvez additionner les valeurs en utilisant array_sum() puis en fonction du nombre d'éléments que vous voulez pour avoir dans votre tableau résultant, divisez cette somme et remplissez chaque élément que vous voulez conserver avec le résultat de votre division.

(Ici, je suppose que vous utiliserez un second tableau, mais vous pourriez désactiver le fichier inutile si vous le préférez de cette façon).

Answer 3

Voici mon coup de couteau à votre question

<pre> 
<?php 

class Thingy 
{ 
    protected $store; 
    protected $universe; 

    public function __construct(array $data) 
    { 
    $this->store = $data; 
    $this->universe = array_sum($data); 
    } 

    public function reduceTo($size) 
    { 
    // Guard condition incase reduction size is too big 
    $storeSize = count($this->store); 
    if ($size >= $storeSize) 
    { 
     return $this->store; 
    } 

    // Odd number of elements must be handled differently 
    if ($storeSize & 1) 
    { 
     $chunked = array_chunk($this->store, ceil($storeSize/2)); 
     $middleValue = array_pop($chunked[0]); 

     $chunked = array_chunk(array_merge($chunked[0], $chunked[1]), floor($storeSize/$size)); 

     // Distribute odd-man-out amonst other values 
     foreach ($chunked as &$chunk) 
     { 
     $chunk[] = $middleValue/$size; 
     } 
    } else { 
     $chunked = array_chunk($this->store, floor($storeSize/$size)); 
    } 

    return array_map('array_sum', $chunked); 
    } 

} 

$tests = array(
    array(2, array(25, 50, 25)) 
    , array(2, array(10, 15, 20, 25)) 
    , array(2, array(10, 10, 10, 10, 11)) 
    , array(6, array_fill(0, 15, 1)) 
); 

foreach($tests as $test) 
{ 
    $t = new Thingy($test[1]); 
    print_r($t->reduceTo($test[0])); 
} 

?> 
</pre>