Find all combinations of n numbers of a given set of numbers

Question

i want to write a app to find all possible combinations of n numbers of a given set of numbers and return a hashset of them.. for example if a give set{1,5,7,9} and size of set 2 then i will take:

[1, 5] [1, 7] [1, 9] [5, 7] [5, 9]

i have the following code from this post but i can't modified it for a given size of set every time.

import java.util.ArrayList;
import java.util.Arrays;

class SumSet {
    static void sum_up_recursive(ArrayList<Integer> numbers,ArrayList<Integer> partial) {

       System.out.println("sum("+Arrays.toString(partial.toArray())+")=");

       for(int i=0;i<numbers.size();i++) 
       {
           ArrayList<Integer> remaining = new ArrayList<Integer>();
             int n = numbers.get(i);
             for (int j=i+1; j<numbers.size();j++) 
                 remaining.add(numbers.get(j));

             ArrayList<Integer> partial_rec = new ArrayList<Integer>(partial);
             partial_rec.add(n);
             sum_up_recursive(remaining,partial_rec);
       }
    }
    static void sum_up(ArrayList<Integer> numbers) {
        sum_up_recursive(numbers,new ArrayList<Integer>());
    }
    public static void main(String args[]) {
        Integer[] numbers = {1,5,7,9};
        sum_up(new ArrayList<Integer>(Arrays.asList(numbers)));
    }
}

Answer 1

thank you all... Also i found this solution

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;

public class Comb {

    static HashSet combine(Integer[] arr, int k, int startId, int[] branch, int numElem,HashSet arrSet)
    {
        if (numElem == k)
        {
            //System.out.println("k: "+k+(Arrays.toString(branch)));
            ArrayList<Integer> mySet = new ArrayList<Integer>();
            for(int i=0;i<branch.length;i++)
            {
                mySet.add(branch[i]);
            }
            arrSet.add(mySet);
            return arrSet;
        }

        for (int i = startId; i < arr.length; ++i)
        {
            branch[numElem++]=arr[i];
            combine(arr, k, ++startId, branch, numElem, arrSet);
            --numElem;
        }
        return arrSet;
    }

    public static void main(String args[]) 
    {
        int k = 3;
        Integer[] input ={1,5,7,9}; "ABCD".toCharArray(); 
        int[] branch = new int[k];//{0,0};//new char[k];
        HashSet arrSet=new HashSet();
        arrSet=combine(input, k, 0, branch, 0, arrSet);
    }
}

Answer 2

I changed recursive method from niiraj874u's answer to return a value. So now it gives list of hash sets as you wanted.

static List<Set<Integer>> sum_up_recursive(List<Integer> numbers,
        Set<Integer> partial , int sizeOfset) {

    List<Set<Integer>> result = new ArrayList<Set<Integer>>();

    if(partial.size() == sizeOfset)
        result.add(partial);

    for (int i = 0; i < numbers.size(); i++) {
        ArrayList<Integer> remaining = new ArrayList<Integer>();
        int n = numbers.get(i);
        for (int j = i + 1; j < numbers.size(); j++)
            remaining.add(numbers.get(j));

        Set<Integer> partial_rec = new HashSet<Integer>(partial);
        partial_rec.add(n);
        result.addAll(sum_up_recursive(remaining, partial_rec, sizeOfset));
    }

    return result;
}

public static void main(String args[]) {
    Integer[] numbers = { 1, 5, 7, 9 };
    int size = 2;

    List<Set<Integer>> allCombinations = sum_up_recursive(Arrays.asList(numbers), new HashSet<Integer>(), size);

    for (Set<Integer> set : allCombinations) {
        for (Integer num : set)
            System.out.print(num + " ");
        System.out.println();
    }
}

Answer 3

package com.app.atb;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

public class Challenge {

    public static void main(String[] args) {

        Set<Integer> myset = new HashSet<Integer>();
        myset.add(1);
        myset.add(5);
        myset.add(7);
        myset.add(9);

        List<Set<Integer>> achieved = solveChallenge(myset);
        System.out.println(achieved);
    }

    public static List<Set<Integer>> solveChallenge(Set<Integer> myset) {

        int n = myset.size();
        Integer[] myInts = new Integer[n];
        Iterator<Integer> iterator = myset.iterator();
        int index = 0;
        while (iterator.hasNext()) {
            myInts[index] = iterator.next();
            ++index;
        }

        List<Set<Integer>> myList = new ArrayList<Set<Integer>>();
        Set<Integer> subSet;
        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {

                if (j != i) {
                    subSet = new HashSet<Integer>();
                    subSet.add(myInts[i]);
                    subSet.add(myInts[j]);
                    myList.add(subSet);
                }

            }
        }
        return myList;
    }
}

Answer 4

We can add one more parameter sizeOfset in SumSet.sum_up_recursive(ArrayList<Integer>, ArrayList<Integer>, int) method like below. please run it tell me Does it give the output what you want ?

import java.util.ArrayList;
import java.util.Arrays;

public class SumSet {
    static void sum_up_recursive(ArrayList<Integer> numbers,
            ArrayList<Integer> partial , int sizeOfset) {

        if(partial.size() == sizeOfset)
        {
            System.out.println("sum(" + Arrays.toString(partial.toArray()) + ")=");
        }

        for (int i = 0; i < numbers.size(); i++) {
            ArrayList<Integer> remaining = new ArrayList<Integer>();
            int n = numbers.get(i);
            for (int j = i + 1; j < numbers.size(); j++)
                remaining.add(numbers.get(j));

            ArrayList<Integer> partial_rec = new ArrayList<Integer>(partial);
            partial_rec.add(n);
            sum_up_recursive(remaining, partial_rec, sizeOfset);
        }
    }

    static void sum_up(ArrayList<Integer> numbers) {
        sum_up_recursive(numbers, new ArrayList<Integer>(), 2);
    }

    public static void main(String args[]) {
        Integer[] numbers = { 1, 5, 7, 9 };
        sum_up(new ArrayList<Integer>(Arrays.asList(numbers)));
    }
}