How to get all the combination in order - algorithm

Question

For example
Input
2,1,3
Output
1,1,1
1,1,2
1,1,3
2,1,1
2,1,2
2,1,3

Answer 1

If I correctly understand the question then this should work (code is in Haskell, will produce the results in a different order than the example)
combinations [] = []
combinations [x]
|x > 0 = [x]:combinations [(x-1)]
|otherwise = []
combinations (x:xs)
|x > 0 = (map (\c -> x:c) (combinations xs)) ++ combinations((x-1):xs)
|otherwise = []
Or this to get it in the same order as you gave (also just a nicer solution)
combinations' [x] = [[c]|c<-[1..x]]
combinations' (x:xs) = [c:d|c<-[1..x],d<-combinations' xs]
It will take me a bit to produce an answer in an "imperative" language (C, Java, etc). This is the kind of thing where functional languages shine.
Okay, so in Java.
Disclaimer: this code is more or less just a direct translation of the Haskell. It isn't clean, or the best way of doing things. I have not tested it, or really given it enough thought to make sure it is correct
public List<List<Integer>> combinations(List<Integer> workwith){
List<List<Integer>> d = new LinkedList<LinkedList<Integer>>();
if(workwith.size() == 1){
int max = workwith.get(0);
for(int i = 1; i=<max;i++){
List<Integer> toAdd = new LinkedList<Integer>();
toAdd.add(i);
d.add(toAdd);
}
return d
}
Integer max = workwith.remove(0);
List<List<Integer>> back = combinations(workwith);
for(int i = 1, i<=max;i++)
for(List<Integer> b: back){
List<Integer> toAdd = new LinkedList<Integer>();
toAdd.add(i);
toAdd.addAll(b);
d.add(toAdd)
}
}
return d;
}

Answer 2

a[] - is an input vector
int prod = 1;
for (int i = 0; i < a.size(); i++) prod *= a[i]; // find the count of lines in output
for (int i = 0; i < prod; i++){
vector<int> b; // vector of the current output
for (int j = a.size()-1; j >= 0; j--){ // for each output calculate its values
b[j] = i % a[j]; // each value will be between 0 and a[j]
i /= a[j];
}
for (int j = 0; j < a.size(); j++) // output it
cout << b[j] + 1 << " ";
cout << endl;
}

Answer 3

Not the most efficient way to do it, but here's a C implementation:
/* Assumes output is allocated with enough room for 'len' ints. */
/* Generates the 'num'-th combination in 'output'. */
void get_comb_number(int num, int len, int *input, int *output) {
int i;
for (i=num-i-1; i >= 0; --i) {
output[i] = (num % input[i]) + 1;
num /= input[i];
}
}
Then you can just loop from 0 to the product of the input (for the example above it would be 2*1*3 = 6), calling get_comb_number for each and print out each combination. The code is slightly inefficient because it has to call a function for each combination and has to do all the mods and divisions for each combination, but IMO the simplicity of the code makes up for it if you don't need the efficiency. Note that the combination number will overflow somewhat quickly, but assuming 32-bit ints, you'll be spending several minutes just generating all the combinations at that point and much much longer trying to print them all.