Subsets of a specific length

Question

I have a Vector of Integers, like so: {1, 2, 4, 7}, and I need to generate all subsets of a given size. So if I wanted all the subsets of size three for the above set, I would get: {{1, 2, 4}, {1, 2, 7}, {1, 4, 7}, and {2, 4, 7}}.
How can I generate all these subsets? I found the following code (by schillj) posted on another topic, but it generates all possible subsets of all possible sizes, where I only need ones of a given size:
int[] arr = new int[] {1,2,3,4};
long num_permutations = (1<<(arr.length));
System.out.println("Number of permutations = " + num_permutations);
// print out all the sets
for(int loop = 0; loop < num_permutations; loop++) {
  System.out.print("Set #" + loop + ":  ");
  // do the bit chunking
  for(int bit = 0; bit < arr.length; bit++) {
    if(0 != (loop & (1<<bit)) ) {
      System.out.print( arr[bit] + " ");
  System.out.println("");
}Any ideas how I might generate my subsets?

Answer 1

Well, after working at it for a while, here's what I've come up with... It's not elegant, but I post it here in case anyone else is interested. I'd be interested to hear if anyone has a simpler or more elegant solution to what seems like it should be a simple problem.
// Given a set (a Vector) v, generates all the subsets of this set of
// the given length. Returns a Vector of Vectors (each of which is one
// of the subsets).
public static Vector subsetsOfSize(Vector v, int s) {
  // Initialize the positions array.  Each element is set to its index.
  int[] positions = new int[s];
  for (int i = 0; i < positions.length; i++) {
    positions[i] = i;
  // Generate all the subsets of size s
  int maxVal = v.size() - 1;
  boolean maxedOut = false;
  Vector subsets = new Vector();
  do {
    subsets.add(createSubset(v, positions));
    maxedOut = rIncrementVars(positions, 0, maxVal);
  } while (maxedOut == false);
  subsets.add(createSubset(v, positions));
  return subsets;
// A helper function used by subsetsOfSize().
private static Vector createSubset(Vector v, int[] positions) {
  Vector subset = new Vector();
  for (int i = 0; i < positions.length; i++) {
    subset.add(v.get(positions));
return subset;
// Recursively increments any number of variables in the manner used by
// subsetsOfSize(). That is, it creates all the combinations of the
// (vars.length) numbers from 0 to maxVal. Returns true to the calling
// function when it has generated the last such combination, returns
// false otherwise. The first time this function is called, vars
// should be an array with each element set to its index.
private static boolean rIncrementVars(int[] vars, int n, int maxVal) {
boolean incThisVar;
if (n < vars.length - 1) {
incThisVar = rIncrementVars(vars, n + 1, maxVal);
} else {
incThisVar = true;
if (incThisVar == true) {
int maxValN = maxVal - (vars.length - 1 - n);
if (vars[n] < maxValN) {
vars[n]++;
for (int i = n + 1; i < vars.length; i++) {
vars[i] = vars[i - 1] + 1;
if (n == 0 && vars[n] == maxValN) {
return true;
} else {
return false;
} else {
return true;
} else {
return false;