Показать возможные комбинации строк

Question

Я пытаюсь взять строку и отобразить возможные ее комбинации (в PHP), но при этом говорю по порядку каждого слова.Например: «как дела» вернет (массив)

How are you
How are
are you
how
you
are

Код, который у меня есть, теперь отображает все комбинации, но я хочу, чтобы он содержал их в порядке, а не переворачивал слова.У кого-нибудь есть идеи или фрагменты, которыми они хотят поделиться?Спасибо

Answer 1

Установите два итератора и напечатайте все между ними.Так что-то вроде этого:

<?
$str = "How are you";
$words = explode(" ",$str);
$num_words = count($words);
for ($i = 0; $i < $num_words; $i++) {
  for ($j = $i; $j < $num_words; $j++) {
    for ($k = $i; $k <= $j; $k++) {
       print $words[$k] . " ";
    }
    print "\n";
  }
}
?>

Выход

---

How 
How are 
How are you 
are 
are you 
you 

Answer 2

Я знаю, что это очень старый пост, но другой ответ не очень гибок, поэтому я подумал, что смогу принести новый ответ.

Объяснение

Итак, вы ищете все комбинации, которые были бы:

(2 ⁿ ) - 1

Что в вашем конкретном примере будет:

(2 ³ ) - 1 = (8) - 1 = 7

Так как мне получить все комбинации сейчас? Мы перебираем все наши комбинации, которые у нас уже есть (начиная с одной комбинации, «пустой комбинации» ($results = [[]];)), и для каждой комбинации мы проходим наше следующее слово из массива и объединяем каждую комбинацию с каждой новой слово для новой комбинации.

* * Пример тысячи двадцать-шести * 1 028 *

Array with the words/numbers (Empty array is '[]'):
[1, 2, 3]

                               //↓new combinations for the next iteration
                               │
iteration 0:

    Combinations:
                  - []         │  -> []
                                  │
iteration 1:        ┌─────────────┤
                    │             │
    Combinations:   v             v
                  - []    + 1  │  -> [1]    
                                  │
iteration 2:        ┌─────────────┤
                    │             │
    Combinations:   v             v
                  - []    + 2  │  -> [2]
                  - [1]   + 2  │  -> [1,2]    
                                  │
iteration 3:        ┌─────────────┤
                    │             │
    Combinations:   v             v
                  - []    + 3  │  -> [3]
                  - [1]   + 3  │  -> [1,3]
                  - [2]   + 3  │  -> [2,3]         
                  - [1,2] + 3  │  -> [1,2,3]    
                               //^ All combinations here

Итак, как вы можете видеть, всегда есть: (2^n)-1 комбинаций. Кроме того, от этого метода в массиве комбинаций остается пустой массив, поэтому перед возвращением массива я просто использую array_filter(), чтобы удалить все пустые массивы, и array_values(), чтобы переиндексировать весь массив.

Код

<?php

    $str = "how are you";


    function getCombinations($array) {

        //initalize array
        $results = [[]];

        //get all combinations
        foreach ($array as $k => $element) {
            foreach ($results as $combination)
                $results[] =  $combination + [$k => $element];
        }

        //return filtered array
        return array_values(array_filter($results));

    }


    $arr = getCombinations(explode(" ", $str));

    foreach($arr as $v)
        echo implode(" ", $v) . "<br />";


?>

выход:

how
are
how are
you
how you
are you
how are you

Answer 3

Ответ на вопрос Комбинация массивов PHP без обратного порядка . Там нужно было получить все возможные комбинации элементов массива и сохранить следующее.

<?php

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

// recursively create all possible combinations {
combine($alphabet, $result, $arrResult);

function combine($shiftedAlphabet, &$result, &$arrResult) {
    global $alphabet;

    $currentElementStr = '';
    $currentElementArr = array();
    for($i = 0; $i < count($shiftedAlphabet); ++$i) {
        $newElement = $shiftedAlphabet[$i];
        $currentElementStr .= $newElement;
        $currentElementArr[] = $newElement;

        if(!in_array($currentElementStr, $result)) { // if not duplicated => push it to result
            // find right position {
            $thisCount = count($currentElementArr);
            $indexFrom = 0;
            $indexToInsert = 0;

            // find range of indexes with current count of elements {
            foreach ($arrResult as $arrResultKey => $arrResultValue) {
                $indexToInsert = $arrResultKey + 1;
                if ($thisCount > count($arrResultValue)) {
                    $indexFrom = $indexToInsert;
                }
                if ($thisCount < count($arrResultValue)) {
                    --$indexToInsert;
                    break;
                }
            }
            // find range of indexes with current count of elements }

            // find true index inside true range {
            $trueIndex = $indexToInsert;
            $break = false;
            for($j = $indexFrom; $j < $indexToInsert; ++$j) {
                $trueIndex = $j + 1;
                foreach($arrResult[$j] as $key => $value) {
                    if (array_search($value, $alphabet) > array_search($currentElementArr[$key], $alphabet)) {
                        $break = true;
                        break;
                    }
                }
                if($break) {
                    --$trueIndex;
                    break;
                }
            }
            // find true index inside true range }

            array_splice($result, $trueIndex, 0, $currentElementStr);
            array_splice($arrResult, $trueIndex, 0, array($currentElementArr));
        }
    }

    for($i = 0; $i < count($shiftedAlphabet) - 1; ++$i) {
        $tmpShiftedAlphabet = $shiftedAlphabet; // for combining all possible subcombinations
        array_splice($tmpShiftedAlphabet, $i, 1);
        combine($tmpShiftedAlphabet, $result, $arrResult);
    }
}
// recursively create all possible combinations }
var_dump($result); 

?>

Пример результата здесь