blocks|key|653427|text|为什么不使用数据库来做到这一点呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|653428|在MySQL中很容易做到。|653429|table+arm
+++id+integer+primary+key
+++label+char

table+gender
+++id+integer+primary+key
+++gender+enum('male','female')

table+location
+++id+integer+primary+key
+++city+varchar(255)|code-block|syntax|javascript|653430|然后执行查询|653431|$query+=+mysql_query("+
++SELECT+a.label,+g.gender,+l.city
++FROM+arm+a
++CROSS+JOIN+gender+g
++CROSS+JOIN+location+l
++ORDER+BY+a.id
")+or+die("Could+not+execute+query");

while($row+=+mysql_fetch_array($query)+)
{
+++....
}|653432|把它读出来：|653433|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Why not use a database to do this? 

It's easy in MySQL..

<pre><code>table arm
 id integer primary key
 label char

table gender
 id integer primary key
 gender enum('male','female')

table location
 id integer primary key
 city varchar(255)
</code></pre>

Then do a query

<pre><code>$query = mysql_query(" 
 SELECT a.label, g.gender, l.city
 FROM arm a
 CROSS JOIN gender g
 CROSS JOIN location l
 ORDER BY a.id
") or die("Could not execute query");

while($row = mysql_fetch_array($query) )
{
 ....
}
</code></pre>

And read that out:

blocks|key|653470|text|我很快调整了你的代码，我的尝试是粗糙的，但看看这是否如你所想的那样工作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|653471|$result+=+array();
$nm+=+'';
foreach+($map+as+$name+=>+$a)+{
++++if+(empty($result))+{
++++++++$result+=+$a;
++++++++$nm+=+$name;
++++++++continue;
++++}

++++$res+=+array();
++++foreach+($result+as+$r)+{
++++++++foreach+($a+as+$v)+{
++++++++++++$myr+=+$r;
++++++++++++$myv+=+$v;
++++++++++++if(!is_array($r))+$myr+=+array($nm+=>+$r);
++++++++++++if(!is_array($v))+$myv+=+array($name+=>+$v);

++++++++++++$res[]+=+array_merge($myr,+$myv);
++++++++}
++++}
++++$result+=+$res;
}
echo+"<pre>";
print_r($result);|code-block|syntax|javascript|653472|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I quickly adjusted your code a bit , my attempt is crude i think but see if this works as you want:

<pre><code>$result = array();
$nm = '';
foreach ($map as $name =&gt; $a) {
 if (empty($result)) {
 $result = $a;
 $nm = $name;
 continue;
 }

 $res = array();
 foreach ($result as $r) {
 foreach ($a as $v) {
 $myr = $r;
 $myv = $v;
 if(!is_array($r)) $myr = array($nm =&gt; $r);
 if(!is_array($v)) $myv = array($name =&gt; $v);

 $res[] = array_merge($myr, $myv);
 }
 }
 $result = $res;
}
echo "&lt;pre&gt;";
print_r($result);
</code></pre>

blocks|key|870834|text|下面是@Jon的笛卡尔函数的优化版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|870835|function+cartesian($input)+{
++++$result+=+array(array());

++++foreach+($input+as+$key+=>+$values)+{
++++++++$append+=+array();

++++++++foreach($result+as+$product)+{
++++++++++++foreach($values+as+$item)+{
++++++++++++++++$product[$key]+=+$item;
++++++++++++++++$append[]+=+$product;
++++++++++++}
++++++++}

++++++++$result+=+$append;
++++}

++++return+$result;
}|code-block|syntax|javascript|870836|阅读更多关于此算法背后的数学知识：http://en.wikipedia.org/wiki/Cartesian_product|offset|length|870837|查看该算法不同语言的更多示例：https://rosettacode.org/wiki/Cartesian_product_of_two_or_more_lists|870838|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Cartesian_product|1|https://rosettacode.org/wiki/Cartesian_product_of_two_or_more_lists^0|0|0|H|1A|0|0|F|1V|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@$I|Z|J|10|1|11]]|A|$]]|$1|K|3|L|5|6|7|12|8|@]|9|@$I|13|J|14|1|15]]|A|$]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]|U|$5|P|Q|R|A|$S|V]]]]

Here is optimized version of @Jon's cartesian function:

<pre><code>function cartesian($input) {
 $result = array(array());

 foreach ($input as $key =&gt; $values) {
 $append = array();

 foreach($result as $product) {
 foreach($values as $item) {
 $product[$key] = $item;
 $append[] = $product;
 }
 }

 $result = $append;
 }

 return $result;
}
</code></pre>

Read more about the math behind this algorithm: <a href="http://en.wikipedia.org/wiki/Cartesian_product" rel="noreferrer">http://en.wikipedia.org/wiki/Cartesian_product</a>

See more examples of this algorithm in different languages: <a href="https://rosettacode.org/wiki/Cartesian_product_of_two_or_more_lists" rel="noreferrer">https://rosettacode.org/wiki/Cartesian_product_of_two_or_more_lists</a>

blocks|key|870886|text|为什么不使用递归生成器..。内存问题:几乎没有|type|unstyled|depth|inlineStyleRanges|entityRanges|data|870887|(而且它很美)|870888|function+cartesian($a)
{
++++if+($a)
++++{
++++++++if($u=array_pop($a))
++++++++++++foreach(cartesian($a)as$p)
++++++++++++++++foreach($u+as$v)
++++++++++++++++++++yield+$p%2B[count($p)=>$v];
++++}
++++else
++++++++yield[];
}|code-block|syntax|javascript|870889|注意:这不会保留密钥；但这是一个开始。|870890|这应该可以做到(未测试)：|870891|function+acartesian($a)
{
++++if+($a)
++++{
++++++++$k=end(array_keys($a));
++++++++if($u=array_pop($a))
++++++++++++foreach(acartesian($a)as$p)
++++++++++++++++foreach($u+as$v)
++++++++++++++++++++yield+$p%2B[$k=>$v];
++++}
++++else
++++++++yield[];
}|870892|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|V|8|@]|9|@]|A|$G|H]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Why not use a recursive generator ... memory issues: close to none 
(and it´s beautiful)

<pre><code>function cartesian($a)
{
 if ($a)
 {
 if($u=array_pop($a))
 foreach(cartesian($a)as$p)
 foreach($u as$v)
 yield $p+[count($p)=&gt;$v];
 }
 else
 yield[];
}
</code></pre>

note: this does not preserve keys; but it´s a start.

This should do (not tested):

<pre><code>function acartesian($a)
{
 if ($a)
 {
 $k=end(array_keys($a));
 if($u=array_pop($a))
 foreach(acartesian($a)as$p)
 foreach($u as$v)
 yield $p+[$k=&gt;$v];
 }
 else
 yield[];
}
</code></pre>

blocks|key|653595|text|一种算法是在每个步骤中使用当前步骤项目扩展以前的结果：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|653596|function+cartezian1($inputArray)
{
++++$results+=+[];

++++foreach+($inputArray+as+$group)+{
++++++++$results+=+expandItems($results,+$group);
++++}

++++return+$results;
}

function+expandItems($sourceItems,+$tails)
{
++++$result+=+[];

++++if+(empty($sourceItems))+{
++++++++foreach+($tails+as+$tail)+{
++++++++++++$result[]+=+[$tail];
++++++++}
++++++++return+$result;
++++}

++++foreach+($sourceItems+as+$sourceItem)+{
++++++++foreach+($tails+as+$tail)+{
++++++++++++$result[]+=+array_merge($sourceItem,+[$tail]);
++++++++}
++++}

++++return+$result;
}|code-block|syntax|javascript|653597|此解决方案使用内存存储所有组合，然后一次性返回所有组合。所以，它很快，但它需要大量的内存。此外，不使用递归函数。|653598|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

One algorithm is to expand at each step the previous results with the current step items:

<pre><code>function cartezian1($inputArray)
{
 $results = [];

 foreach ($inputArray as $group) {
 $results = expandItems($results, $group);
 }

 return $results;
}

function expandItems($sourceItems, $tails)
{
 $result = [];

 if (empty($sourceItems)) {
 foreach ($tails as $tail) {
 $result[] = [$tail];
 }
 return $result;
 }

 foreach ($sourceItems as $sourceItem) {
 foreach ($tails as $tail) {
 $result[] = array_merge($sourceItem, [$tail]);
 }
 }

 return $result;
}
</code></pre>

This solution uses memory to store the all combinations then returns them all at once. So, it's fast but it needs a lot of memory. Also, recursive functions are not used.

blocks|key|653645|text|如果内存消耗很重要，或者最后不需要所有的组合，那么可以使用迭代器一次生成一个组合。如果你需要所有的组合，你可以使用iterator_to_array。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|653646|function+cartezianIterator($inputArray)
{
++++$maximumPosition+=+array_map('count',+$inputArray);
++++$position+=+array_pad([],+count($inputArray),+0);

++++while+(false+!==+($item+=+buildItemAtPosition($inputArray,+$position)))+{

++++++++yield+$item;

++++++++$position+=+incrementPosition($position,+$maximumPosition);
++++}
}

function+buildItemAtPosition($inputArray,+$positions)
{
++++if+($positions[0]+>=+count($inputArray[0]))+{
++++++++return+false;
++++}

++++$item+=+[];
++++foreach+($inputArray+as+$rowIndex+=>+$row)+{
++++++++$position+=+$positions[$rowIndex];

++++++++$item[]+=+$row[$position];
++++}

++++return+$item;
}

function+incrementPosition($position,+$maximumPosition)
{
++++$digitToIncrement+=+count($position)+-+1;

++++do+{
++++++++$position[$digitToIncrement]%2B%2B;

++++++++if+($position[$digitToIncrement]+<+$maximumPosition[$digitToIncrement]+%7C%7C+0+===+$digitToIncrement)+{
++++++++++++//no+overflow
++++++++++++break;
++++++++}

++++++++//overflow,+reset+to+zero+and+increment+parent+digit
++++++++$position[$digitToIncrement]+=+0;

++++++++$digitToIncrement--;
++++}+while+($digitToIncrement+>=+0);

++++return+$position;
}|code-block|syntax|javascript|653647|然后，要一次获得一个解决方案，您可以使用foreach或next，如下所示：|653648|$iterator+=+cartezianIterator($inputArray);

//of+course,+you+need+to+do+something+with+the+result...
$combination+=+next($iterator);
$combination+=+next($iterator);
$combination+=+next($iterator);
$combination+=+next($iterator);
$combination+=+next($iterator);
$combination+=+next($iterator);|653649|如果你只需要几个组合，这个解决方案是非常非常快的。此外，内存消耗非常低(它使用平面array来存储一些integers)。|653650|注意:不使用递归函数。|653651|entityMap^0|1L|H|0|0|K|7|S|4|0|0|15|5|1F|8|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|19|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|T|$]]

If memory consumption is important or you don't need all the combinations in the end you could use an iterator to generate one combination at a time. If you need all the combinations you can use <code>iterator_to_array</code>.

<pre><code>function cartezianIterator($inputArray)
{
 $maximumPosition = array_map('count', $inputArray);
 $position = array_pad([], count($inputArray), 0);

 while (false !== ($item = buildItemAtPosition($inputArray, $position))) {

 yield $item;

 $position = incrementPosition($position, $maximumPosition);
 }
}

function buildItemAtPosition($inputArray, $positions)
{
 if ($positions[0] &gt;= count($inputArray[0])) {
 return false;
 }

 $item = [];
 foreach ($inputArray as $rowIndex =&gt; $row) {
 $position = $positions[$rowIndex];

 $item[] = $row[$position];
 }

 return $item;
}

function incrementPosition($position, $maximumPosition)
{
 $digitToIncrement = count($position) - 1;

 do {
 $position[$digitToIncrement]++;

 if ($position[$digitToIncrement] &lt; $maximumPosition[$digitToIncrement] || 0 === $digitToIncrement) {
 //no overflow
 break;
 }

 //overflow, reset to zero and increment parent digit
 $position[$digitToIncrement] = 0;

 $digitToIncrement--;
 } while ($digitToIncrement &gt;= 0);

 return $position;
}
</code></pre>

Then, to get one solution at a time you could use a <code>foreach</code> or <code>next</code>, like this:

<pre><code>$iterator = cartezianIterator($inputArray);

//of course, you need to do something with the result...
$combination = next($iterator);
$combination = next($iterator);
$combination = next($iterator);
$combination = next($iterator);
$combination = next($iterator);
$combination = next($iterator);
</code></pre>

This solution is very very fast if you need only a few combinations. 
Also, the memory consumption is very low (it uses a flat <code>array</code> to store some <code>integers</code>).

Note: recursive functions are not used.

blocks|key|871049|text|在PHP+7中，@Serg的答案可以缩短为：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|871050|function+cartesian(array+$input)
{
++++$result+=+[[]];
++++foreach+($input+as+$key+=>+$values)+{
++++++++$append+=+[];
++++++++foreach+($values+as+$value)+{
++++++++++++foreach+($result+as+$data)+{
++++++++++++++++$append[]+=+$data+%2B+[$key+=>+$value];
++++++++++++}
++++++++}
++++++++$result+=+$append;
++++}

++++return+$result;
}|code-block|syntax|javascript|871051|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In PHP 7 @Serg's answer can be shortened to:

<pre><code>function cartesian(array $input)
{
 $result = [[]];
 foreach ($input as $key =&gt; $values) {
 $append = [];
 foreach ($values as $value) {
 foreach ($result as $data) {
 $append[] = $data + [$key =&gt; $value];
 }
 }
 $result = $append;
 }

 return $result;
}
</code></pre>

Say that I have an array like the following:

<pre><code>Array
(
 [arm] =&gt; Array
 (
 [0] =&gt; A
 [1] =&gt; B
 [2] =&gt; C
 )
 [gender] =&gt; Array
 (
 [0] =&gt; Female
 [1] =&gt; Male
 )
 [location] =&gt; Array
 (
 [0] =&gt; Vancouver
 [1] =&gt; Calgary
 )
)
</code></pre>

How can I find the cartesian product while preserving the keys of the outer associative array and using them in the inner ones? The result of the algorithm should be this:

<pre><code>Array
(
 [0] =&gt; Array
 (
 [arm] =&gt; A
 [gender] =&gt; Female
 [location] =&gt; Vancouver
 )

 [1] =&gt; Array
 (
 [arm] =&gt; A
 [gender] =&gt; Female
 [location] =&gt; Calgary
 )

 [2] =&gt; Array
 (
 [arm] =&gt; A
 [gender] =&gt; Male
 [location] =&gt; Vancouver
 )

...etc.
</code></pre>

I've looked up quite a number of cartesian product algorithms but I'm getting stuck on the specifics of how to preserve the associative keys. The current algorithm I am using gives numerical indices only:

<pre><code> $result = array();
 foreach ($map as $a) {
 if (empty($result)) {
 $result = $a;
 continue;
 }
 $res = array();
 foreach ($result as $r) {
 foreach ($a as $v) {
 $res[] = array_merge((array)$r, (array)$v);
 }
 }
 $result = $res;
 }

 print_r($result);
</code></pre>

Any help would be appreciated.

Finding cartesian product with PHP associative arrays

数据库

MySQL

假设我有一个如下所示的数组：Array(    [arm] => Array        (            [0] => A            [1] => B            [2] => C        )    [gender] => Array        (            [0...

问使用PHP关联数组查找笛卡尔乘积
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用PHP关联数组查找笛卡尔乘积EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用PHP关联数组查找笛卡尔乘积
EN