Question

It should quite simple algorithm, but I just can’t get around it.

I have some arrays in alphabetical order

[0] => Array
    (
        [0] => a
        [1] => b
        [2] => c
    )

and for example

[0] => Array
    (
        [0] => a
        [1] => b
        [2] => c
        [3] => d
    )

and I need to sort them into rows. For example:

I should receive a table with 3 columns and as many rows as it may get and it should be in alphabetical order.

Here is an example:
First array should be converted into

[0] => Array
    (
        [0] => Array
            (
                [0] => a
                [1] => b
                [2] => c
            )

    )

But second one should be as

[1] => Array
    (
        [0] => Array
            (
                [0] => a
                [1] => c
                [2] => d
            )
        [1] => Array
            (
                [0] => b
            )
    )

I’m writing it in php, so if anyone can help I would be really appreciated.

UPD:
Code example:

function sortAsOrdered( array $categories )
{
    foreach ( $categories as $groupId => $group )
    {
        $regroupMenuItems = array();
        $limit            = count( $group );
        $rows             = ceil( $limit / 3 );

        for ( $i = 0; $i < $rows; ++$i )
        {
            $jumper = 0;

            for ( $j = 0; $j < 3; $j++ )
            {
                if ( 0 == $jumper )
                {
                    $jumper = $i;
                }

                if ( isset( $group[ $jumper ] ) )
                {
                    $regroupMenuItems[ $i ][ $j ] = $group[ $jumper ];
                }

                $jumper = $jumper + $rows;
            }
        }

        $categories[ $groupId ] = $regroupMenuItems;
    }

    return $categories;
}

Guys I solved this one. Here you could see my algorithm http://pastebin.com/xe2yjhYW.
But don’t be sad your help will not go in vain. I probably will place bounty just for those who helped with this dificult algorithm for me.

Guys thanks one more time. Your thoughts inspired me to think differently.

Answer 1

If to say it shortly, then here is a method for that algorithm.

/**
 * @param array $toTransform
 * @param int $columnsMax
 * @return array
 */
private function transformation( array $toTransform, $columnsMax = 3 )
{
    // First divide array as you need
    $listlen   = count( $toTransform );
    $partlen   = floor( $listlen / $columnsMax );
    $partrem   = $listlen % $columnsMax;
    $partition = array();
    $mark      = 0;

    for ( $px = 0; $px < $columnsMax; $px++ )
    {
        $incr             = ( $px < $partrem ) ? $partlen + 1 : $partlen;
        $partition[ $px ] = array_slice( $toTransform, $mark, $incr );
        $mark             += $incr;
    }

    // Secondly fill empty slots for easy template use
    $result = array();

    for ( $i = 0; $i < count( $partition[0] ); $i++ )
    {
        $tmp = array();

        foreach ( $partition as $column )
        {
            if ( isset( $column[ $i ] ) )
            {
                $tmp[] = $column[ $i ];
            }
            else
            {
                $tmp[] = '';
            }
        }

        $result[] = $tmp;
    }

    return $result;
}

Also I included PHPUnit test for that. You can find it at, that link.