Generate all combinaties of an array, not always using all arrays - php

Question

I'm working on a piece of code that should generate all combinations of a set of filters. All the values of a filter are in an array, which creates a multidimensional array of filters. The end result should be all possible url combinations with the filters; e.a:
/lorem
/lorem/foo
/lorem/foo/
/lorem/foo/primary
But also
/primary
/primary/ipsum
/primary/bar
etcetera.
I got this piece of code, which I believe is already from StackOverflow;
<?php
$parts = [];
$parts[] = ['lorem', 'ipsum'];
$parts[] = ['foo', 'bar'];
$parts[] = ['primary', 'secondary'];
$parts[] = ['test-value'];
echo "<pre>";
var_dump( create_all_combinations($parts) );
echo "</pre>";
function create_all_combinations($arrays)
{
$result = array();
$arrays = array_values($arrays);
$sizeIn = sizeof($arrays);
$size = $sizeIn > 0 ? 1 : 0;
foreach ($arrays as $array)
$size = $size * sizeof($array);
for ($i = 0; $i < $size; $i ++)
{
$result[$i] = array();
for ($j = 0; $j < $sizeIn; $j ++)
array_push($result[$i], current($arrays[$j]));
for ($j = ($sizeIn -1); $j >= 0; $j --)
{
if (next($arrays[$j]))
break;
elseif (isset ($arrays[$j]))
reset($arrays[$j]);
}
}
return $result;
}
Currently the result is always with 4 urls (since we feed 4 different filters). I am missing the unique combinaties of 1, 2 or 3 filter combination and I'm not sure where to start to create this. Any help appreciated.

Answer 1

be wary. beware.
In this post I will provide essential functions where I have manage the complexity to a meticulous degree. A beginner should be able to step thru them and verify the behaviour along the way. It is my goal to help prevent copy/paste development -
Cargo cult programming is symptomatic of a programmer not understanding either a bug they were attempting to solve or the apparent solution. The term cargo cult programmer may apply when anyone inexperienced with the problem at hand copies some program code from one place to another with little understanding of how it works or whether it is required.
The functions below are written with functional style principles. That means avoiding things like mutation, variable reassignment and other side effects. Instead of destroying old values, we will create new ones. This makes writing functions and debugging a lot easier. If you have any questions, don't hesitate to ask :D
array_combinations
I would break your problem down into several pieces. First, a generic combinations function which generates combinations of any multi-dimensional array -
function array_combinations (array $a) {
if (count($a) == 0)
yield [];
else
foreach (array_combinations(array_slice($a, 1)) as $c)
foreach ($a[0] as $v)
yield array_merge([$v], array_filter($c));
}
$t = [[3,6], ["a","b"], [9]];
foreach (array_combinations($t) as $c)
echo json_encode($c), PHP_EOL;
[3,"a",9]
[6,"a",9]
[3,"b",9]
[6,"b",9]
array_transpose
But according to your question, you want the transpose variant of this output. So we simply write a function for that too -
function array_transpose (array $a) {
return array_map(null, ...$a);
}
$t = [[3,6], ["a","b"], [9]];
foreach (array_combinations(array_transpose($t)) as $c)
echo json_encode($c), PHP_EOL;
[3,6]
["a",6]
[9,6]
[3,"b"]
["a","b"]
[9,"b"]
[3]
["a"]
[9]
combine
Complex programs are made up of several smaller programs -
$parts = [
['lorem', 'ipsum'],
['foo', 'bar'],
['primary', 'secondary'],
['test-value'],
];
foreach (array_combinations(array_transpose($parts)) as $c)
echo "/".join("/", $c), PHP_EOL;
/lorem/ipsum
/foo/ipsum
/primary/ipsum
/test-value/ipsum
/lorem/bar
/foo/bar
/primary/bar
/test-value/bar
/lorem/secondary
/foo/secondary
/primary/secondary
/test-value/secondary
/lorem
/foo
/primary
/test-value
without generators
If you do not want to use generators, adhering to functional principles is more challenging but still worth it. The complexity ramps up here considerably and you should use the generator, if possible -
function array_combinations (array $a) {
if (count($a) == 0)
return [[]];
else
return array_flatmap(
array_combinations(array_slice($a, 1)),
function ($c) use ($a) {
return array_map(function($v) use ($c) {
return array_merge([$v], array_filter($c));
}, $a[0]);
}
);
}
Where array_flatmap is defined as -
function array_flatmap (array $a, callable $f) {
return array_reduce($a, function ($r, $v) use ($f) {
return array_merge($r, $f($v));
}, []);
}
with arrow functions
If you are on PHP >= 7.4, you can use the new arrow functions, which cleans up the generatorless approach significantly -
function array_combinations (array $a) {
if (count($a) == 0)
return [[]];
else
return array_flatmap(
array_combinations(array_slice($a, 1)),
fn($c) => array_map(
fn($v) => array_merge([$v], array_filter($c)),
$a[0]
)
);
}
Where array_flatmap is defined as -
function array_flatmap (array $a, callable $f) {
return array_reduce(
$a,
fn($r, $v) => array_merge($r, $f($v)),
[]
);
}
Usage and output of each variant is the same.