# Print all subsets of given size of a set

Generate all possible subset of size r of given array with distinct elements.

Examples:

```Input  : arr[] = {1, 2, 3, 4}
r = 2
Output :  1 2
1 3
1 4
2 3
2 4
3 4

Input  : arr[] = {10, 20, 30, 40, 50}
r = 3
Output : 10 20 30
10 20 40
10 20 50
10 30 40
10 30 50
10 40 50
20 30 40
20 30 50
20 40 50
30 40 50 ```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

This problem is same as Print all possible combinations of r elements in a given array of size n.

The idea here is similar to Subset Sum Problem. We one by one consider every element of input array, and recur for two cases:

1) The element is included in current combination (We put the element in data[] and increment next available index in data[])
2) The element is excluded in current combination (We do not put the element and do not change index)

When number of elements in data[] become equal to r (size of a combination), we print it.

This method is mainly based on Pascal’s Identity, i.e. ncr = n-1cr + n-1cr-1

## C++

 `// Program to print all combination of size r in ` `// an array of size n ` `#include ` `void` `combinationUtil(``int` `arr[], ``int` `n, ``int` `r, ` `                     ``int` `index, ``int` `data[], ``int` `i); ` ` `  `// The main function that prints all combinations of  ` `// size r in arr[] of size n. This function mainly ` `// uses combinationUtil() ` `void` `printCombination(``int` `arr[], ``int` `n, ``int` `r) ` `{ ` `    ``// A temporary array to store all combination ` `    ``// one by one ` `    ``int` `data[r]; ` ` `  `    ``// Print all combination using temprary array 'data[]' ` `    ``combinationUtil(arr, n, r, 0, data, 0); ` `} ` ` `  `/* arr[]  ---> Input Array ` `   ``n      ---> Size of input array ` `   ``r      ---> Size of a combination to be printed ` `   ``index  ---> Current index in data[] ` `   ``data[] ---> Temporary array to store current combination ` `   ``i      ---> index of current element in arr[]     */` `void` `combinationUtil(``int` `arr[], ``int` `n, ``int` `r, ``int` `index, ` `                     ``int` `data[], ``int` `i) ` `{ ` `    ``// Current cobination is ready, print it ` `    ``if` `(index == r) { ` `        ``for` `(``int` `j = 0; j < r; j++) ` `            ``printf``(``"%d "``, data[j]); ` `        ``printf``(``"\n"``); ` `        ``return``; ` `    ``} ` ` `  `    ``// When no more elements are there to put in data[] ` `    ``if` `(i >= n) ` `        ``return``; ` ` `  `    ``// current is included, put next at next location ` `    ``data[index] = arr[i]; ` `    ``combinationUtil(arr, n, r, index + 1, data, i + 1); ` ` `  `    ``// current is excluded, replace it with next ` `    ``// (Note that i+1 is passed, but index is not ` `    ``// changed) ` `    ``combinationUtil(arr, n, r, index, data, i + 1); ` `} ` ` `  `// Driver program to test above functions ` `int` `main() ` `{ ` `    ``int` `arr[] = { 10, 20, 30, 40, 50 }; ` `    ``int` `r = 3; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``printCombination(arr, n, r); ` `    ``return` `0; ` `} `

## Java

 `// Java program to print all combination of size ` `// r in an array of size n ` `import` `java.io.*; ` ` `  `class` `Permutation { ` ` `  `    ``/* arr[]  ---> Input Array ` `    ``data[] ---> Temporary array to store current combination ` `    ``start & end ---> Staring and Ending indexes in arr[] ` `    ``index  ---> Current index in data[] ` `    ``r ---> Size of a combination to be printed */` `    ``static` `void` `combinationUtil(``int` `arr[], ``int` `n, ``int` `r, ` `                          ``int` `index, ``int` `data[], ``int` `i) ` `    ``{ ` `        ``// Current combination is ready to be printed,  ` `        ``// print it ` `        ``if` `(index == r) { ` `            ``for` `(``int` `j = ``0``; j < r; j++) ` `                ``System.out.print(data[j] + ``" "``); ` `            ``System.out.println(``""``); ` `            ``return``; ` `        ``} ` ` `  `        ``// When no more elements are there to put in data[] ` `        ``if` `(i >= n) ` `            ``return``; ` ` `  `        ``// current is included, put next at next ` `        ``// location ` `        ``data[index] = arr[i]; ` `        ``combinationUtil(arr, n, r, index + ``1``,  ` `                               ``data, i + ``1``); ` ` `  `        ``// current is excluded, replace it with ` `        ``// next (Note that i+1 is passed, but ` `        ``// index is not changed) ` `        ``combinationUtil(arr, n, r, index, data, i + ``1``); ` `    ``} ` ` `  `    ``// The main function that prints all combinations ` `    ``// of size r in arr[] of size n. This function  ` `    ``// mainly uses combinationUtil() ` `    ``static` `void` `printCombination(``int` `arr[], ``int` `n, ``int` `r) ` `    ``{ ` `        ``// A temporary array to store all combination ` `        ``// one by one ` `        ``int` `data[] = ``new` `int``[r]; ` ` `  `        ``// Print all combination using temprary ` `        ``// array 'data[]' ` `        ``combinationUtil(arr, n, r, ``0``, data, ``0``); ` `    ``} ` ` `  `    ``/* Driver function to check for above function */` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `arr[] = { ``10``, ``20``, ``30``, ``40``, ``50` `}; ` `        ``int` `r = ``3``; ` `        ``int` `n = arr.length; ` `        ``printCombination(arr, n, r); ` `    ``} ` `} ` `/* This code is contributed by Devesh Agrawal */`

## Python3

 `# Python program to print all ` `# subset combination of n  ` `# element in given set of r element . ` ` `  `# arr[] ---> Input Array ` `# data[] ---> Temporary array to  ` `#             store current combination ` `# start & end ---> Staring and Ending  ` `#                  indexes in arr[] ` `# index ---> Current index in data[] ` `# r ---> Size of a combination  ` `#        to be printed  ` `def` `combinationUtil(arr, n, r,  ` `                    ``index, data, i): ` `    ``# Current combination is  ` `    ``# ready to be printed, ` `    ``# print it ` `    ``if``(index ``=``=` `r): ` `        ``for` `j ``in` `range``(r): ` `            ``print``(data[j], end ``=` `" "``) ` `        ``print``(``" "``) ` `        ``return` ` `  `    ``# When no more elements  ` `    ``# are there to put in data[] ` `    ``if``(i >``=` `n): ` `        ``return` ` `  `    ``# current is included,  ` `    ``# put next at next ` `    ``# location  ` `    ``data[index] ``=` `arr[i] ` `    ``combinationUtil(arr, n, r,  ` `                    ``index ``+` `1``, data, i ``+` `1``) ` `     `  `    ``# current is excluded,  ` `    ``# replace it with ` `    ``# next (Note that i+1  ` `    ``# is passed, but index  ` `    ``# is not changed) ` `    ``combinationUtil(arr, n, r, index,  ` `                    ``data, i ``+` `1``) ` ` `  ` `  `# The main function that ` `# prints all combinations ` `# of size r in arr[] of  ` `# size n. This function  ` `# mainly uses combinationUtil() ` `def` `printcombination(arr, n, r): ` ` `  `    ``# A temporary array to ` `    ``# store all combination ` `    ``# one by one ` `    ``data ``=` `list``(``range``(r)) ` `     `  `    ``# Print all combination  ` `    ``# using temporary  ` `    ``# array 'data[]' ` `    ``combinationUtil(arr, n, r,  ` `                    ``0``, data, ``0``) ` ` `  ` `  `# Driver Code ` `arr ``=` `[``10``, ``20``, ``30``, ``40``, ``50``] ` ` `  `r ``=` `3` `n ``=` `len``(arr) ` `printcombination(arr, n, r) ` ` `  `# This code is contributed ` `# by Ambuj sahu `

## C#

 `// C# program to print all combination ` `// of size r in an array of size n ` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``/* arr[] ---> Input Array ` `    ``data[] ---> Temporary array to store ` `    ``current combination start & end ---> ` `    ``Staring and Ending indexes in arr[] ` `    ``index ---> Current index in data[] ` `    ``r ---> Size of a combination to be ` `    ``printed */` `    ``static` `void` `combinationUtil(``int` `[]arr, ` `                  ``int` `n, ``int` `r, ``int` `index, ` `                          ``int` `[]data, ``int` `i) ` `    ``{ ` `         `  `        ``// Current combination is ready to ` `        ``// be printed, print it ` `        ``if` `(index == r) ` `        ``{ ` `            ``for` `(``int` `j = 0; j < r; j++) ` `                ``Console.Write(data[j] + ``" "``); ` `                 `  `            ``Console.WriteLine(``""``); ` `             `  `            ``return``; ` `        ``} ` ` `  `        ``// When no more elements are there ` `        ``// to put in data[] ` `        ``if` `(i >= n) ` `            ``return``; ` ` `  `        ``// current is included, put next ` `        ``// at next location ` `        ``data[index] = arr[i]; ` `        ``combinationUtil(arr, n, r, index + 1,  ` `                                ``data, i + 1); ` ` `  `        ``// current is excluded, replace ` `        ``// it with next (Note that i+1  ` `        ``// is passed, but index is not ` `        ``// changed) ` `        ``combinationUtil(arr, n, r, index, ` `                                ``data, i + 1); ` `    ``} ` ` `  `    ``// The main function that prints all ` `    ``// combinations of size r in arr[] of ` `    ``// size n. This function mainly uses ` `    ``// combinationUtil() ` `    ``static` `void` `printCombination(``int` `[]arr, ` `                                ``int` `n, ``int` `r) ` `    ``{ ` `         `  `        ``// A temporary array to store all ` `        ``// combination one by one ` `        ``int` `[]data = ``new` `int``[r]; ` ` `  `        ``// Print all combination using ` `        ``// temprary array 'data[]' ` `        ``combinationUtil(arr, n, r, 0, data, 0); ` `    ``} ` ` `  `    ``/* Driver function to check for ` `    ``above function */` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `[]arr = { 10, 20, 30, 40, 50 }; ` `        ``int` `r = 3; ` `        ``int` `n = arr.Length; ` `         `  `        ``printCombination(arr, n, r); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m. `

## PHP

 ` Input Array ` `n ---> Size of input array ` `r ---> Size of a combination to be printed ` `index ---> Current index in data[] ` `data[] ---> Temporary array to store  ` `current combination ` `i ---> index of current element in arr[] */` `function` `combinationUtil( ``\$arr``, ``\$n``, ``\$r``, ``\$index``, ` `                    ``\$data``, ``\$i``) ` `{ ` `    ``// Current cobination is ready, print it ` `    ``if` `(``\$index` `== ``\$r``) { ` `        ``for` `( ``\$j` `= 0; ``\$j` `< ``\$r``; ``\$j``++) ` `            ``echo` `\$data``[``\$j``],``" "``; ` `        ``echo` `"\n"``; ` `        ``return``; ` `    ``} ` ` `  `    ``// When no more elements are there to ` `    ``// put in data[] ` `    ``if` `(``\$i` `>= ``\$n``) ` `        ``return``; ` ` `  `    ``// current is included, put next at  ` `    ``// next location ` `    ``\$data``[``\$index``] = ``\$arr``[``\$i``]; ` `    ``combinationUtil(``\$arr``, ``\$n``, ``\$r``, ``\$index` `+ 1,  ` `                              ``\$data``, ``\$i` `+ 1); ` ` `  `    ``// current is excluded, replace it with ` `    ``// next (Note that i+1 is passed, but  ` `    ``// index is not changed) ` `    ``combinationUtil(``\$arr``, ``\$n``, ``\$r``, ``\$index``,  ` `                            ``\$data``, ``\$i` `+ 1); ` `} ` ` `  `// Driver program to test above functions ` `    ``\$arr` `= ``array``( 10, 20, 30, 40, 50 ); ` `    ``\$r` `= 3; ` `    ``\$n` `= ``count``(``\$arr``); ` `    ``printCombination(``\$arr``, ``\$n``, ``\$r``); ` ` `  `// This code is contributed by anuj_67. ` `?> `

Output:

```10 20 30
10 20 40
10 20 50
10 30 40
10 30 50
10 40 50
20 30 40
20 30 50
20 40 50
30 40 50
```

Refer below post for more solutions and ideas to handle duplicates in input array.
Print all possible combinations of r elements in a given array of size n.

This article is contributed by Dhiman Mayank. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Improved By : vt_m, AmbujSahu

Article Tags :
Practice Tags :

4

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.