Mostra le possibili combinazioni di string

Sto cercando di prendere una string e visualizzare le possibili combinazioni di essa (in PHP), ma mentre dico in ordine di each parola. Ad esempio: "come stai" verrebbe restituito (un arrays)

How are you How are are you how you are 

Il codice che ho ora mostra tutte le combinazioni, ma sto cercando di tenerle in ordine e non di capovolgere le parole. Qualcuno ha qualche idea o frammento che gli interessa condividere? Grazie

Imposta due iteratori e printing tutto tra di loro. Quindi qualcosa del genere:

 <? $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"; } } ?> 

Produzione


 How How are How are you are are you you 

So che questo è un post molto vecchio, ma l'altra risposta non è molto flessibile, quindi ho pensato di inserire una nuova risposta.

Spiegazione

Quindi stai cercando tutte le combinazioni che sarebbero:

(2 n ) – 1

Quale nel tuo esempio specifico sarebbe:

(2 3 ) – 1 = (8) – 1 = 7

Quindi come faccio a get tutte le combinazioni ora? Passiamo in rassegna tutte le nostre combinazioni, che abbiamo già (Iniziando con una combinazione, una "combinazione vuota" ( $results = [[]]; )), e per each combinazione passiamo attraverso la nostra prossima parola dalla matrix e combiniamo each combinazione con each nuova parola in una nuova combinazione.

Esempio

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

  //↓new combinations for the next iteration │ iteration 0: Combinations: - [] │ -> [] │ iteration 1: ┌─────────────┤ │ │ Combinations: vv - [] + 1 │ -> [1] │ iteration 2: ┌─────────────┤ │ │ Combinations: vv - [] + 2 │ -> [2] - [1] + 2 │ -> [1,2] │ iteration 3: ┌─────────────┤ │ │ Combinations: vv - [] + 3 │ -> [3] - [1] + 3 │ -> [1,3] - [2] + 3 │ -> [2,3] - [1,2] + 3 │ -> [1,2,3] //^ All combinations here 

Quindi come puoi vedere c'è sempre: (2^n)-1 combinazioni in totale. Anche da questo metodo c'è un arrays vuoto rimasto nell'arrays di combinazione, quindi prima di restituire l'arrays uso semplicemente arrays_filter() per rimuovere tutti gli arrays vuoti e arrays_values() per reindicizzare l'integer arrays.

Codice

 <?php $str = "how are you"; function getCombinations($arrays) { //initalize arrays $results = [[]]; //get all combinations foreach ($arrays as $k => $element) { foreach ($results as $combination) $results[] = $combination + [$k => $element]; } //return filtered arrays return arrays_values(arrays_filter($results)); } $arr = getCombinations(explode(" ", $str)); foreach($arr as $v) echo implode(" ", $v) . "<br />"; ?> 

produzione:

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

Risposta per domande Combinazione di arrays PHP con ordine arretrato . È stato necessario get tutte le possibili combinazioni di elementi dell'arrays e memorizzare quanto segue.

 <?php $alphabet = arrays('a','b','c'); $result = arrays(); $arrResult = arrays(); // recursively create all possible combinations { combine($alphabet, $result, $arrResult); function combine($shiftedAlphabet, &$result, &$arrResult) { global $alphabet; $currentElementStr = ''; $currentElementArr = arrays(); for($i = 0; $i < count($shiftedAlphabet); ++$i) { $newElement = $shiftedAlphabet[$i]; $currentElementStr .= $newElement; $currentElementArr[] = $newElement; if(!in_arrays($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 (arrays_search($value, $alphabet) > arrays_search($currentElementArr[$key], $alphabet)) { $break = true; break; } } if($break) { --$trueIndex; break; } } // find true index inside true range } arrays_splice($result, $trueIndex, 0, $currentElementStr); arrays_splice($arrResult, $trueIndex, 0, arrays($currentElementArr)); } } for($i = 0; $i < count($shiftedAlphabet) - 1; ++$i) { $tmpShiftedAlphabet = $shiftedAlphabet; // for combining all possible subcombinations arrays_splice($tmpShiftedAlphabet, $i, 1); combine($tmpShiftedAlphabet, $result, $arrResult); } } // recursively create all possible combinations } var_dump($result); ?> 

Esempio di risultato qui