Obtendo todas as combinações possíveis em PHP: uma solução abrangente

Recuperar todas as combinações possíveis de um array 1D pode ser uma tarefa complexa, especialmente quando considerando combinações e permutações. Embora existam várias abordagens para este problema, uma solução altamente eficaz envolve a implementação de uma função recursiva.

A função recursiva, deep_picker(), realiza uma pesquisa em profundidade na matriz, explorando todas as ramificações e combinando elementos para formar combinações. Ele mantém uma string temporária que é gradualmente modificada a cada elemento, enquanto um array de coleta armazena as combinações finais. Vamos examinar como esta função funciona:

1. Base Case: Se a string temporária estiver vazia, significa que um elemento independente está sendo considerado. Neste caso, ele é adicionado diretamente ao array de coleta.
2. Exploração Recursiva: Quando um elemento deve ser combinado, a função cria uma cópia do array original e remove o elemento atual disso. Em seguida, ele chama recursivamente deep_picker() no array modificado, passando a string temporária atualizada com o elemento adicionado. Se houver mais elementos para combinar, ele continua o processo recursivo.
3. Combinações e Permutações: Ao iterar cada elemento e combiná-los recursivamente, deep_picker() gera efetivamente todas as combinações e permutações possíveis sem repetição. Essa abordagem garante que ambas as variações de strings ('Alpha Beta' e 'Beta Alpha') sejam incluídas no resultado final.
4. Resultado final: quando a função tiver explorado todas as combinações, a coleta array contém o conjunto completo de todas as combinações possíveis do array de entrada.

Implementação e execução

Para implementar esta pesquisa em profundidade e recuperação de combinações, o seguinte código PHP pode ser empregado:

 0) {
            depth_picker($arrcopy, $temp_string ." " . $elem[0], $collect);
        } else {
            $collect []= $temp_string. " " . $elem[0];
        }
    }
}

$collect = array();
depth_picker($array, "", $collect);
print_r($collect);

?>

Após a execução, este código gera o seguinte array de todas as combinações e arranjos possíveis:

Array
(
    [0] =>  Alpha
    [1] =>  Alpha Beta
    [2] =>  Alpha Beta Gamma
    [3] =>  Alpha Beta Gamma Sigma
    [4] =>  Alpha Beta Sigma
    [5] =>  Alpha Beta Sigma Gamma
    [6] =>  Alpha Gamma
    [7] =>  Alpha Gamma Beta
    [8] =>  Alpha Gamma Beta Sigma
    [9] =>  Alpha Gamma Sigma
    [10] =>  Alpha Gamma Sigma Beta
    [11] =>  Alpha Sigma
    [12] =>  Alpha Sigma Beta
    [13] =>  Alpha Sigma Beta Gamma
    [14] =>  Alpha Sigma Gamma
    [15] =>  Alpha Sigma Gamma Beta
    [16] =>  Beta
    [17] =>  Beta Alpha
    [18] =>  Beta Alpha Gamma
    [19] =>  Beta Alpha Gamma Sigma
    [20] =>  Beta Alpha Sigma
    [21] =>  Beta Alpha Sigma Gamma
    [22] =>  Beta Gamma
    [23] =>  Beta Gamma Alpha
    [24] =>  Beta Gamma Alpha Sigma
    [25] =>  Beta Gamma Sigma
    [26] =>  Beta Gamma Sigma Alpha
    [27] =>  Beta Sigma
    [28] =>  Beta Sigma Alpha
    [29] =>  Beta Sigma Alpha Gamma
    [30] =>  Beta Sigma Gamma
    [31] =>  Beta Sigma Gamma Alpha
    [32] =>  Gamma
    [33] =>  Gamma Alpha
    [34] =>  Gamma Alpha Beta
    [35] =>  Gamma Alpha Beta Sigma
    [36] =>  Gamma Alpha Sigma
    [37] =>  Gamma Alpha Sigma Beta
    [38] =>  Gamma Beta
    [39] =>  Gamma Beta Alpha
    [40] =>  Gamma Beta Alpha Sigma
    [41] =>  Gamma Beta Sigma
    [42] =>  Gamma Beta Sigma Alpha
    [43] =>  Gamma Sigma
    [44] =>  Gamma Sigma Alpha
    [45] =>  Gamma Sigma Alpha Beta
    [46] =>  Gamma Sigma Beta
    [47] =>  Gamma Sigma Beta Alpha
    [48] =>  Sigma
    [49] =>  Sigma Alpha
    [50] =>  Sigma Alpha Beta
    [51] =>  Sigma Alpha Beta Gamma
    [52] =>  Sigma Alpha Gamma
    [53] =>  Sigma Alpha Gamma Beta
    [54] =>  Sigma Beta
    [55] =>  Sigma Beta Alpha
    [56] =>  Sigma Beta Alpha Gamma
    [57] =>  Sigma Beta Gamma
    [58] =>  Sigma Beta Gamma Alpha
    [59] =>  Sigma Gamma
    [60] =>  Sigma Gamma Alpha
    [61] =>  Sigma Gamma Alpha Beta
    [62] =>  Sigma Gamma Beta
    [63] =>  Sigma Gamma Beta Alpha
)

Essa abordagem fornece uma solução abrangente e eficiente para obter todas as combinações possíveis de elementos em uma matriz, garantindo que ambas as combinações e arranjos diferentes sejam incluídos na saída.