Question

我有一组字符串，每个字符串都有一个由管道（|）分隔的可变数量的段，例如：

$string = 'abc|b|ac';

每个具有多个char的段应该扩展为所有可能的一个char组合，对于3个段，以下“算法”运行得非常好：

$result = array();
$string = explode('|', 'abc|b|ac');

foreach (str_split($string[0]) as $i)
{
    foreach (str_split($string[1]) as $j)
    {
        foreach (str_split($string[2]) as $k)
        {
            $result[] = implode('|', array($i, $j, $k)); // more...
        }
    }
}

print_r($result);

输出：

$result = array('a|b|a', 'a|b|c', 'b|b|a', 'b|b|c', 'c|b|a', 'c|b|c');

显然，对于3个以上的段，代码开始变得非常混乱，因为我需要添加（并检查）越来越多的内部循环。我尝试提出动态解决方案，但我无法弄清楚如何为所有细分（单独和整体）生成正确的组合。我还查看了一些组合数学源代码，但我无法组合我的段的不同组合。

如果有人能指出我正确的方向，我感激不尽。

Answer 1

Recursion救援（您可能需要调整一下以覆盖边缘情况，但它有效）：

function explodinator($str) {
    $segments = explode('|', $str);
    $pieces = array_map('str_split', $segments);

    return e_helper($pieces);
}

function e_helper($pieces) {

    if (count($pieces) == 1)
        return $pieces[0];

    $first = array_shift($pieces);
    $subs = e_helper($pieces);

    foreach($first as $char) {
        foreach ($subs as $sub) {
            $result[] = $char . '|' . $sub;
        }
    }

    return $result;
}

print_r(explodinator('abc|b|ac'));

输出：

Array
(
    [0] => a|b|a
    [1] => a|b|c
    [2] => b|b|a
    [3] => b|b|c
    [4] => c|b|a
    [5] => c|b|c
)

见ideone。

Answer 2

这看起来像递归编程的工作！：P 我第一次看到这个，并认为它将是一个在线（可能是在perl）。还有其他非递归方式（例如，将所有索引组合枚举成段然后循环）但我认为这更有趣，可能“更好”。

 $str = explode('|', 'abc|b|ac');
 $strlen = count( $str );
 $results = array();

 function splitAndForeach( $bchar , $oldindex, $tempthread) {
     global $strlen, $str, $results;
     $temp = $tempthread;
     $newindex = $oldindex + 1;

     if ( $bchar != '') { array_push($temp, $bchar ); }

     if ( $newindex <= $strlen ){
         print "starting foreach loop on string '".$str[$newindex-1]."' \n";

         foreach(str_split( $str[$newindex - 1] ) as $c) {
             print "Going into next depth ($newindex) of recursion on char $c \n";
             splitAndForeach( $c , $newindex, $temp);
         }

     } else {

        $found = implode('|', $temp);
        print "Array length (max recursion depth) reached, result: $found \n";

        array_push( $results, $found );
        $temp = $tempthread;
        $index = 0;
        print "***************** Reset index to 0 *****************\n\n";
     }
 }

 splitAndForeach('', 0, array() );
 print "your results: \n";
 print_r($results);

Answer 3

您可以拥有两个阵列：替代品和当前计数器。

$alternatives = array(array('a', 'b', 'c'), array('b'), array('a', 'c'));
$counter = array(0, 0, 0);

然后，在循环中，递增计数器的“最后一位”，如果该值等于该位置的备选数量，则将该“数字”重置为零并将“数字”增加到左侧它。这就像用十进制数计数一样。

每个步骤的字符串是通过连接每个数字的$alternatives[$i][$counter[$i]]构建的。

当“第一个数字”变得与该数字的替代数量一样大时，您就完成了。

示例：对于上述变量，计数器将在以下步骤中获得以下值：

0,0,0
0,0,1
1,0,0 (overflow in the last two digit)
1,0,1
2,0,0 (overflow in the last two digits)
2,0,1
3,0,0 (finished, since the first "digit" has only 3 alternatives)

“展开”一个字符串

3 个答案: