From Rosetta code #include <algorithm> #include <iostream> #include <string> void comb(int N, int K) { std::string bitmask(K, 1); // K leading 1’s bitmask.resize(N, 0); // N-K trailing 0’s // print integers and permute bitmask do { for (int i = 0; i < N; ++i) // [0..N-1] integers { if (bitmask[i]) std::cout << ” ” … Read more
The Formula It’s actually very easy to compute N choose K without even computing factorials. We know that the formula for (N choose K) is: N! ——– (N-K)!K! Therefore, the formula for (N choose K+1) is: N! N! N! N! (N-K) —————- = ————— = ——————– = ——– x —– (N-(K+1))!(K+1)! (N-K-1)! (K+1)! (N-K)!/(N-K) K!(K+1) … Read more
Sure thing. It is a bit tricky to do this with LINQ but certainly possible using only the standard query operators. UPDATE: This is the subject of my blog on Monday June 28th 2010; thanks for the great question. Also, a commenter on my blog noted that there is an even more elegant query than … Read more
This is very easy with list comprehensions. To get the cartesian product of the lists xs and ys, we just need to take the tuple (x,y) for each element x in xs and each element y in ys. This gives us the following list comprehension: cartProd xs ys = [(x,y) | x <- xs, y … Read more
Ok, thanks @dfan for telling me I was looking in the wrong place. I’ve got it now: from itertools import product def my_product(inp): return (dict(zip(inp.keys(), values)) for values in product(*inp.values()) EDIT: after years more Python experience, I think a better solution is to accept kwargs rather than a dictionary of inputs; the call style is … Read more
This is along the lines of Thijser’s currently incomplete pseudocode. The idea is to take the most frequent of the remaining item types unless it was just taken. (See also Coady’s implementation of this algorithm.) import collections import heapq class Sentinel: pass def david_eisenstat(lst): counts = collections.Counter(lst) heap = [(-count, key) for key, count in … Read more
Yes, there is a “next permutation” algorithm, and it’s quite simple too. The C++ standard template library (STL) even has a function called next_permutation. The algorithm actually finds the next permutation — the lexicographically next one. The idea is this: suppose you are given a sequence, say “32541”. What is the next permutation? If you … Read more
You are looking for the Cartesian Product. In mathematics, a Cartesian product (or product set) is the direct product of two sets. In your case, this would be {1, 2, 3, 4, 5, 6} x {1, 2, 3, 4, 5, 6}. itertools can help you there: import itertools x = [1, 2, 3, 4, 5, … Read more
To describe a permutation of n elements, you see that for the position that the first element ends up at, you have n possibilities, so you can describe this with a number between 0 and n-1. For the position that the next element ends up at, you have n-1 remaining possibilities, so you can describe … Read more
There are several ways to do this. Common methods use recursion, memoization, or dynamic programming. The basic idea is that you produce a list of all strings of length 1, then in each iteration, for all strings produced in the last iteration, add that string concatenated with each character in the string individually. (the variable … Read more