How to get combinations from set of elements? - combinations

Question

I need to generate all combinations without repetitions from an array, I read some about it, that suggest to use recursion
I have an array
arr = [["A"], ["B"], ["C"], ["D"], ["E"], ["F"]]
I read that I can solved this problem using recursion like
function combinations(arr, n, k)
//do something
//then
return combinations(arr, n, k)
In my case [A, B, C, D] is equivalent to [A, B, D, C].
I found this example in C++
http://www.martinbroadhurst.com/combinations.html
But I couldn't reproduce it.
Any suggestion how can I solve this?
PD: I'm using Python, but I more interested in the algorithm than the language.

Answer 1

For any combinatorics problem, the best way to program it is to figure out the recurrence relation for the counting argument. In the case of combinations, the recurrence relation is simply C(n, k) = C(n - 1, k - 1) + C(n - 1, k).
But what does this mean exactly? Notice, that C(n - 1, k - 1) means that we have taken the first element of the array, and need k - 1 more elements from the other n - 1 elements. Similarly, C(n - 1, k) means that we won't choose the first element of our array as one of the k elements. But remember that if k is 0, then C(n, k) = 1, else if n is 0 then C(n, k) = 0. In our problem, k == 0 would return a set containing the empty set, else if n == 0, we would return the empty set. With this is mind, the code structure would look like this:
def combinations(arr, k):
if k == 0:
return [[]]
elif len(arr) == 0:
return []
result = []
chosen = combinations(arr[1:], k - 1) #we choose the first element of arr as one of the k elements we need
notChosen = combinations(arr[1:], k) #first element not chosen in set of k elements
for combination in chosen:
result.append([arr[0]] + combination)
for combination in notChosen:
result.append(combination)
return result
Now, this function can be optimized by performing memoization (but that can be left as an exercise to you, the reader). As an additional exercise, can you sketch out how the permutation function would look like starting from its counting relation?
Hint:
P(n, k) = C(n, k)k! = [C(n - 1, k - 1) + C(n - 1, k)]k! = P(n - 1, k - 1)k + P(n - 1, k)

Answer 2

[Heck... by the time I posted the answer, the C++ tag went away]
[Edited with more examples, including using char]
Comments in the code:
#include <vector>
// Function that recursively does the actual job
template <typename T, typename Function> void doCombinations(
size_t num, const std::vector<T>& values,
size_t start, std::vector<T>& combinationSoFar,
Function action
) {
if(0==num) { // the entire combination is complete
action(combinationSoFar);
}
else {
// walk through with the current position to the right,
// taking care to let enough walking room for the rest of the elements
for(size_t i=start; i<values.size()+1-num; i++) {
// push the current value there
combinationSoFar.push_back(values[i]);
// recursive call with one less element to enter combination
// and one position to the right for the next element to consider
doCombinations(num-1, values, i+1, combinationSoFar, action);
// pop the current value, we are going to move it to the right anyway
combinationSoFar.pop_back();
}
}
}
// function for the user to call. Prepares everything needed for the
// doCombinations
template <typename T, typename Function>
void for_each_combination(
size_t numInCombination,
const std::vector<T>& values,
Function action
) {
std::vector<T> combination;
doCombinations(numInCombination, values, 0, combination, action);
}
// dummy do-something with the vector
template <typename T> void cout_vector(const std::vector<T>& v) {
std::cout << '[';
for(size_t i=0; i<v.size(); i++) {
if(i) {
std::cout << ",";
}
std::cout << v[i];
}
std::cout << ']' << std::endl;
}
// Assumes the T type supports both addition and ostream <<
template <typename T> void adder(const std::vector<T>& vals) {
T sum=static_cast<T>(0);
for(T v : vals) {
sum+=v;
}
std::cout << "Sum: " << sum << " for ";
cout_vector(vals);
}
int main() {
std::cout << "Char combinations" << std::endl;
std::vector<char> char_vals{'A', 'B', 'C', 'D', 'E'};
for_each_combination(3, char_vals, cout_vector<char>);
std::cout << "\nInt combinations" << std::endl;
std::vector<int> int_vals{0, 1, 2, 3, 4};
for_each_combination(3, int_vals, cout_vector<int>);
std::cout <<"\nFloat combination adder" << std::endl;
std::vector<float> float_vals{0.0, 1.1, 2.2, 3.3, 4.4};
for_each_combination(3, float_vals, adder<float>);
return 0;
}
Output:
Char combinations
[A,B,C]
[A,B,D]
[A,B,E]
[A,C,D]
[A,C,E]
[A,D,E]
[B,C,D]
[B,C,E]
[B,D,E]
[C,D,E]
Int combinations
[0,1,2]
[0,1,3]
[0,1,4]
[0,2,3]
[0,2,4]
[0,3,4]
[1,2,3]
[1,2,4]
[1,3,4]
[2,3,4]
Float combination adder
Sum: 3.3 for [0,1.1,2.2]
Sum: 4.4 for [0,1.1,3.3]
Sum: 5.5 for [0,1.1,4.4]
Sum: 5.5 for [0,2.2,3.3]
Sum: 6.6 for [0,2.2,4.4]
Sum: 7.7 for [0,3.3,4.4]
Sum: 6.6 for [1.1,2.2,3.3]
Sum: 7.7 for [1.1,2.2,4.4]
Sum: 8.8 for [1.1,3.3,4.4]
Sum: 9.9 for [2.2,3.3,4.4]