пытаясь отсортировать массив массивов с помощью php .. вытаскивая волосы?

Question

Я нахожусь в процессе создания прототипа некоторых статистических графиков с использованием FLOT и php, и я буквально хакирую что-то вместе, чтобы показать что-то.

Однако я столкнулся с проблемой, которая сводит меня с ума...

поэтому у меня есть некоторые данные, которые я извлек из базы данных, а затем, чтобы они легко работали для моего хака Флота, я преобразовал их, чтобы они выглядели примерно так:

[[0,1], [2,1], [4,1], [4,1], [5,1], [9, 1], [9, 1], [10,1], [12,1], [13,1]]

Теперь конечный план состоит в том, чтобы иметь несколько наборов данных, а затем создать составную диаграмму.так что мне нужно сделать, это разобраться, где есть дубликаты, как указано выше, где есть:

[..... [4,1], [4,1] .....]

должен выглядеть следующим образом:

[..... [4,1], [4,2,1] .....]

нижемоя попытка его отсортировать (это последняя итерация попытки, которую я пытался выполнить, изменяя внутренние и внешние значения назад) ...

$count = count($array);
$sorted = false;
while (!$sorted)
{
    $doneSomething = 0;
    for($i = $count - 1; $i > 0; $i--)
    {
        $tempArr = $array[$i];
        foreach($array as $key => $a)
        {
            if($key == $i)
            {
                echo "breaking";
                continue;   
                }
            $result = array_diff($tempArr,$a);
            if(count($result) == 0 )
            {
                $array[$i][1]++;
                if(count($array[$i]) == 3)
                    $array[$i][2]++;
                else
                    $array[$i][] = 1;
                $doneSomething++;
                }
            if($doneSomething > 0)
                break;
            }
        }
    if($doneSomething == 0)
        $sorted=true;
    }

результат такой:

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

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

    [2] => Array
        (
            [0] => 4
            [1] => 2
            [2] => 1
        )

    [3] => Array
        (
            [0] => 4
            [1] => 5
            [2] => 4
        )

    [4] => Array
        (
            [0] => 5
            [1] => 1
        )

    [5] => Array
        (
            [0] => 9
            [1] => 2
            [2] => 1
        )

    [6] => Array
        (
            [0] => 9
            [1] => 3
            [2] => 2
        )

    [7] => Array
        (
            [0] => 10
            [1] => 1
        )

    [8] => Array
        (
            [0] => 12
            [1] => 1
        )

    [9] => Array
        (
            [0] => 13
            [1] => 1
        )

   )

Как вы можете видеть, на самом деле мой предполагаемый результат:

[[0,1], [2,1], [4,1], [4,2,1], [5], 1], [9,1], [9,2,1], [10,1], [12,1], [13,1]]

Если кто-нибудь может помочь мне решить эту проблемубыло бы очень признательно.

спасибо

Вейд

Редактировать: я должен отметить, что если есть только 2 дубликата, это не так уж плохо, я могу это решить, но когдасуществует 3 или более, то есть:

[.... [4,1], [4,1], [4,1], [4,1] ...]

который должен выглядеть следующим образом:

[.... [4,1], [4,2,1], [4,3,2], [4,4,3] ....]

Answer 1

Попробуйте это.Это, кажется, работает нормально здесь:

<?php
    $array = array( array(0,1), array(2,1) , array(4,1) , 
                    array(4,1) , array(5,1) ,array(9 , 1) , 
                    array(9, 1) , array(10,1) , array(12,1), array(13,1) );

    $last_elem = null;
    foreach($array as &$elem){
        if($last_elem){
            if($elem[0] == $last_elem[0]){
                $elem[2] = (isset($last_elem[2]) ? $last_elem[2] + 1 : 1);
                $elem[1] = $last_elem[1] + 1;
            }
        }
        $last_elem = &$elem;
    }

    var_dump($array);
?>

Это работает отлично здесь, я проверил это с этим массивом:
[ [0,1], [2,1], [4,1], [4,1], [4,1], [4,1], [5,1], [9,1], [9,1] ,[9,1] ,[10,1] ,[12,1], [13,1] ];

Вывод:

array
  0 => 
    array
      0 => int 0
      1 => int 1
  1 => 
    array
      0 => int 2
      1 => int 1
  2 => 
    array
      0 => int 4
      1 => int 1
  3 => 
    array
      0 => int 4
      1 => int 2
      2 => int 1
  4 => 
    array
      0 => int 4
      1 => int 3
      2 => int 2
  5 => 
    array
      0 => int 4
      1 => int 4
      2 => int 3
  6 => 
    array
      0 => int 5
      1 => int 1
  7 => 
    array
      0 => int 9
      1 => int 1
  8 => 
    array
      0 => int 9
      1 => int 2
      2 => int 1
  9 => 
    array
      0 => int 9
      1 => int 3
      2 => int 2
  10 => 
    array
      0 => int 10
      1 => int 1
  11 => 
    array
      0 => int 12
      1 => int 1
  12 => &
    array
      0 => int 13
      1 => int 1