Transposing multidimensional arrays in PHP

function transpose($array) {
    array_unshift($array, null);
    return call_user_func_array('array_map', $array);
}

Or if you're using PHP 5.6 or later:

function transpose($array) {
    return array_map(null, ...$array);
}

With 2 loops.

function flipDiagonally($arr) {
    $out = array();
    foreach ($arr as $key => $subarr) {
        foreach ($subarr as $subkey => $subvalue) {
            $out[$subkey][$key] = $subvalue;
        }
    }
    return $out;
}

I think you're referring to the array transpose (columns become rows, rows become columns).

Here is a function that does it for you (source):

function array_transpose($array, $selectKey = false) {
    if (!is_array($array)) return false;
    $return = array();
    foreach($array as $key => $value) {
        if (!is_array($value)) return $array;
        if ($selectKey) {
            if (isset($value[$selectKey])) $return[] = $value[$selectKey];
        } else {
            foreach ($value as $key2 => $value2) {
                $return[$key2][$key] = $value2;
            }
        }
    }
    return $return;
} 

Transposing an N-dimensional array:

function transpose($array, &$out, $indices = array())
{
    if (is_array($array))
    {
        foreach ($array as $key => $val)
        {
            //push onto the stack of indices
            $temp = $indices;
            $temp[] = $key;
            transpose($val, $out, $temp);
        }
    }
    else
    {
        //go through the stack in reverse - make the new array
        $ref = &$out;
        foreach (array_reverse($indices) as $idx)
            $ref = &$ref[$idx];
        $ref = $array;
    }
}

$foo[1][2][3][3][3] = 'a';
$foo[4][5][6][5][5] = 'b';

$out = array();
transpose($foo, $out);

echo $out[3][3][3][2][1] . ' ' . $out[5][5][6][5][4];

Really hackish, and probably not the best solution, but hey it works.

Basically it traverses the array recursively, accumulating the current indicies in an array.
Once it gets to the referenced value, it takes the "stack" of indices and reverses it, putting it into the $out array. (Is there a way of avoiding use of the $temp array?)

Codler's answer fails for a single-row matrix (e.g. [[1,2]]) and also for the empty matrix ([]), which must be special-cased:

function transpose(array $matrix): array {
    if (!$matrix) return [];
    return array_map(count($matrix) == 1 ? fn ($x) => [$x] : null, ...$matrix);
}

(note: PHP 7.4+ syntax, easy enough to adapt for older versions)

I got confronted with the same problem. Here is what i came up with:

function array_transpose(array $arr)
{
    $keys    = array_keys($arr);
    $sum     = array_values(array_map('count', $arr));

    $transposed = array();

    for ($i = 0; $i < max($sum); $i ++)
    {
        $item = array();
        foreach ($keys as $key)
        {
            $item[$key] = array_key_exists($i, $arr[$key]) ? $arr[$key][$i] : NULL;
        }
        $transposed[] = $item;
    }
    return $transposed;
}

Before I start, I'd like to say thanks again to @quazardus for posting his generalised solution for tranposing any two dimenional associative (or non-associative) array!

As I am in the habit of writing my code as tersely as possible I went on to "minimizing" his code a little further. This will very likely not be to everybody's taste. But just in case anyone should be interested, here is my take on his solution:

function arrayMap($cb, array $arrays) // $cb: optional callback function
{   $keys = [];
    array_walk($arrays, function ($array) use (&$keys) 
                        { $keys = array_merge($keys, array_keys($array)); });
    $keys = array_unique($keys); $res = [];
    foreach ($keys as $key) {
      $items = array_map(function ($arr) use ($key)
                         {return isset($arr[$key]) ? $arr[$key] : null; },$arrays);
      $res[$key] = call_user_func(
        is_callable($cb) ? $cb 
                         : function($k, $itms){return $itms;},
        $key, $items);
    }
    return $res;
}

Now, analogous to the PHP standard function array_map(), when you call

arrayMap(null,$b);

you will get the desired transposed matrix.

I needed a transpose function with support for associative array:

    $matrix = [
        ['one' => 1, 'two' => 2],
        ['one' => 11, 'two' => 22],
        ['one' => 111, 'two' => 222],
    ];

    $result = \array_transpose($matrix);

    $trans = [
        'one' => [1, 11, 111],
        'two' => [2, 22, 222],
    ];

And the way back:

    $matrix = [
        'one' => [1, 11, 111],
        'two' => [2, 22, 222],
    ];

    $result = \array_transpose($matrix);

    $trans = [
        ['one' => 1, 'two' => 2],
        ['one' => 11, 'two' => 22],
        ['one' => 111, 'two' => 222],
    ];

The array_unshift trick did not work NOR the array_map...

So I've coded a array_map_join_array function to deal with record keys association:

/**
 * Similar to array_map() but tries to join values on intern keys.
 * @param callable $callback takes 2 args, the intern key and the list of associated values keyed by array (extern) keys.
 * @param array $arrays the list of arrays to map keyed by extern keys NB like call_user_func_array()
 * @return array
 */
function array_map_join_array(callable $callback, array $arrays)
{
    $keys = [];
    // try to list all intern keys
    array_walk($arrays, function ($array) use (&$keys) {
        $keys = array_merge($keys, array_keys($array));
    });
    $keys = array_unique($keys);
    $res = [];
    // for each intern key
    foreach ($keys as $key) {
        $items = [];
        // walk through each array
        array_walk($arrays, function ($array, $arrKey) use ($key, &$items) {
            if (isset($array[$key])) {
                // stack/transpose existing value for intern key with the array (extern) key
                $items[$arrKey] = $array[$key];
            } else {
                // or stack a null value with the array (extern) key
                $items[$arrKey] = null;
            }
        });
        // call the callback with intern key and all the associated values keyed with array (extern) keys
        $res[$key] = call_user_func($callback, $key, $items);
    }
    return $res;
}

and array_transpose became obvious:

function array_transpose(array $matrix)
{
    return \array_map_join_array(function ($key, $items) {
        return $items;
    }, $matrix);
}

Here's a variation of Codler/Andreas's solution that works with associative arrays. Somewhat longer but loop-less purely functional:

<?php
function transpose($array) {
    $keys = array_keys($array);
    return array_map(function($array) use ($keys) {
        return array_combine($keys, $array);
    }, array_map(null, ...array_values($array)));
}

Example:

<?php
$foo = array(
    "fooA" => [ "a1", "a2", "a3"],
    "fooB" => [ "b1", "b2", "b3"],
    "fooC" => [ "c1", "c2", "c3"]
);

print_r( transpose( $foo ));
// Output like this:
Array (
    [0] => Array (
        [fooA] => a1
        [fooB] => b1
        [fooC] => c1
    )

    [1] => Array (
        [fooA] => a2
        [fooB] => b2
        [fooC] => c2
    )

    [2] => Array (
        [fooA] => a3
        [fooB] => b3
        [fooC] => c3
    )
);

We can do this by using Two foreach. Traveling one array and another array to create new array
Like This:

$foo = array(
    'a' => array(
       1 => 'a1',
       2 => 'a2',
       3 => 'a3' 
    ),
    'b' => array(
       1 => 'b1',
       2 => 'b2',
       3 => 'b3' 
    ),
    'c' => array(
       1 => 'c1',
       2 => 'c2',
       3 => 'c3' 
    )
);

$newFoo = [];
foreach($foo as $a => $k){
   foreach($k as $i => $j){
       $newFoo[$i][]= $j;
   }
}

Check The Output

echo "<pre>";
print_r($newFoo);
echo "</pre>";

On the topic of transposing a 2d array, if:

1. You have a (precisely) 2d array with numeric first level keys and non-numeric second level keys AND
2. You need to transpose an array than will be GUARANTEED to have a minimum of 2 rows of data AND
3. You don't need to preserve the numeric first level keys after transposing AND
4. You have a code styling constraint which forbids using language constructs to iterate, THEN...

Code: (Demo)

var_export(
    array_merge_recursive(...$array)
);

The above is more stable than the following script which assumes that all column values will be presented in all rows and be in the same order. Run the following demo to see how 2nd level associations can become broken. (Demo)

var_export(
    array_combine(
        array_keys($array[array_key_first($array)]),
        array_map(null, ...$array)
    )
);

Neither of the above is actually suitable for general use; you need to be 100% confident of the data structure for these techniques to return the correct result. To be more explicit about potential corruptions of data, if either technique is given a 2d array containing a single row, then the output will be a flat, associative array -- this is incorrect transposition. If array_merge_recursive() is fed an empty array it will correctly return an empty array. If the array_combine(array_keys(), array_map()) script is given an empty array it will emit a Warning, then a Fatal error.

For a completely stable means of transposition without using language constructs, you can use nested array_walk() calls, but then you are effectively making an uglier, more convoluted version of a nested foreach() loop structure. This doesn't suffer any of the aforementioned caveats and does preserve the initial first level keys. (Demo)

$result = [];
array_walk($array, function ($row, $i) use (&$result) {
    array_walk($row, function ($v, $k) use (&$result, $i) {
        $result[$k][$i] = $v;
    });
});
var_export($result);

If you want a functional style solution that actually offers a returned value, it is again ugly, but you can use array_reduce(). (Demo)

var_export(
    array_reduce(
        array_keys($array),
        function ($result, $i) use ($array) {
            array_walk($array[$i], function ($v, $k) use (&$result, $i) {
                $result[$k][$i] = $v;
            });
            return $result;
        },
        []
    )
);

If using Laravel, there isn't yet a pre-built transpose() method, so you can declare and use a macro() and that is most simply done by implementing language constructs, but if you still want iteration via Laravel methods, here is a way: (PHPize Demo)

var_export(
    $collection->reduce(
        function($result, $row, $i) {
            collect($row)->each(function($v, $k) use (&$result, $i) {
                $result[$k][$i] = $v;
            });
            return $result;
        },
        []
    )
);

This is another way to do the exact same thing which @codler s answer does. I had to dump some arrays in csv so I used the following function:

function transposeCsvData($data)
{
    $ct=0;
    foreach($data as $key => $val)
    {
        //echo count($val);
        if($ct< count($val))
            $ct=count($val);
        }
    //echo $ct;
    $blank=array_fill(0,$ct,array_fill(0,count($data),null));
    //print_r($blank);

    $retData = array();
    foreach ($data as $row => $columns)
    {
        foreach ($columns as $row2 => $column2) 
        {
            $retData[$row2][$row] = $column2;
            }
        }
    $final=array();
    foreach($retData as $k=>$aval)
    { 
        $final[]=array_replace($blank[$k], $aval);
       }
    return $final;
    }

Test and output reference: https://tutes.in/how-to-transpose-an-array-in-php-with-irregular-subarray-size/

Here is array_walk way to achieve this,

function flipDiagonally($foo){
    $temp = [];
    array_walk($foo, function($item,$key) use(&$temp){
        foreach($item as $k => $v){
            $temp[$k][$key] = $v;     
        }
    });
    return $temp;
}
$bar = flipDiagonally($foo); // Mystery function

Demo.

Variant of Codler's answer with proper support of empty array and 1x1 array:

function transpose($a) {
    if (count($a) < 2) return $a;
    return array_map(null, ...$a);
}

// This short code perfectly works.

$output = [];
foreach ($foo as $key => $subarr) {
    foreach ($subarr as $subkey => $subvalue) {
        $output[$subkey][] = $subvalue;
    }
}
echo "<pre>";
print_r($output);
echo "<pre>";