Question

I have a listbox in C# with the following items:

Package1
Package2
Package3
Package4
Package5
and so on...

The user can select multiple items from this listbox. I need an algorithm in c# or Java (preferably in c#) that can tell me all the possible selections that a user can do, for example Package1 and Package2, Package3 and Package1, Package2, Package4 and Package 3, etc.

Answer 1

You can use recursion, “guess” if the first package is in the combination or not – and invoke recursively without the first package.

Pseudo-code:

combinations(packages, sol):
   if (packages.length == 0): //base clause
      print sol
      return
   package <- packages.first //1 possibility: the first package is in the combination
   packages.removeFirst()
   sol.append(package) 
   combinations(packages,sol) //recursively invoke without the first package
   sol.removeLast() //clean up environment - remove the last added package
   combinations(packages,sol) //2nd possibility: the first package is not in the combination

Notes:

• The empty solution [no package was selected] is assumed to be also a feasible option in this algorithm – if it is not, it can be handled easily in the base clause.
• It is assumed that the order is not important. Package1 AND Package2 is the same as Package2 AND Package1.
• There are 2^n possible combinations for chosing packages, so any algorithm that do what you ask for [including this one] will need O(2^n) time, so I would not try to invoke this algorithm with 100 packages….

In java, it could look something like this:

public static void printCombinations(LinkedList<String> packages, LinkedList<String> sol) {
    if (packages.size() == 0) { 
        System.out.println(sol);
        return;
    }
    String pack = packages.poll(); //also removes the head
    sol.addLast(pack);
    printCombinations(new LinkedList(packages),sol);
    sol.removeLast();
    printCombinations(new LinkedList(packages),sol);
}

and invokation is by:

printCombinations(packages, new LinkedList<String>());

Where packages is a LinkedList with all your packages.

• I used LinkedList for packages and created new objects because I
  find it more clear. To enhance performance – you can use a single
  array with index [which will be changed between recursive calls] in
  order to avoid duplicating packages so many times.