Print all possible combinations of r elements in a given array of size n

Given an array of size n, generate and print all possible combinations of r elements in array. For example, if input array is {1, 2, 3, 4} and r is 2, then output should be {1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4} and {3, 4}.

Following are two methods to do this.

Method 1 (Fix Elements and Recur)
We create a temporary array ‘data[]’ which stores all outputs one by one. The idea is to start from first index (index = 0) in data[], one by one fix elements at this index and recur for remaining indexes. Let the input array be {1, 2, 3, 4, 5} and r be 3. We first fix 1 at index 0 in data[], then recur for remaining indexes, then we fix 2 at index 0 and recur. Finally, we fix 3 and recur for remaining indexes. When number of elements in data[] becomes equal to r (size of a combination), we print data[].

Following diagram shows recursion tree for same input.

Following is implementation of above approach.

 `// C++ program to print all combination  ` `// of size r in an array of size n  ` `#include  ` `using` `namespace` `std;  ` ` `  `void` `combinationUtil(``int` `arr[], ``int` `data[],  ` `                    ``int` `start, ``int` `end,  ` `                    ``int` `index, ``int` `r);  ` ` `  `// 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, data, 0, n-1, 0, r);  ` `}  ` ` `  `/* 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 */` `void` `combinationUtil(``int` `arr[], ``int` `data[],  ` `                    ``int` `start, ``int` `end,  ` `                    ``int` `index, ``int` `r)  ` `{  ` `    ``// Current combination is ready ` `    ``// to be printed, print it  ` `    ``if` `(index == r)  ` `    ``{  ` `        ``for` `(``int` `j = 0; j < r; j++)  ` `            ``cout << data[j] << ``" "``;  ` `        ``cout << endl;  ` `        ``return``;  ` `    ``}  ` ` `  `    ``// replace index with all possible  ` `    ``// elements. The condition "end-i+1 >= r-index" ` `    ``// makes sure that including one element  ` `    ``// at index will make a combination with  ` `    ``// remaining elements at remaining positions  ` `    ``for` `(``int` `i = start; i <= end &&  ` `        ``end - i + 1 >= r - index; i++)  ` `    ``{  ` `        ``data[index] = arr[i];  ` `        ``combinationUtil(arr, data, i+1,  ` `                        ``end, index+1, r);  ` `    ``}  ` `}  ` ` `  `// Driver code  ` `int` `main()  ` `{  ` `    ``int` `arr[] = {1, 2, 3, 4, 5};  ` `    ``int` `r = 3;  ` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr[0]);  ` `    ``printCombination(arr, n, r);  ` `}  ` ` `  `// This code is contributed by rathbhupendra `

 `// Program to print all combination of size r in an array of size n ` `#include ` `void` `combinationUtil(``int` `arr[], ``int` `data[], ``int` `start, ``int` `end,  ` `                     ``int` `index, ``int` `r); ` ` `  `// 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, data, 0, n-1, 0, r); ` `} ` ` `  `/* 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 */` `void` `combinationUtil(``int` `arr[], ``int` `data[], ``int` `start, ``int` `end, ` `                     ``int` `index, ``int` `r) ` `{ ` `    ``// Current combination is ready to be printed, print it ` `    ``if` `(index == r) ` `    ``{ ` `        ``for` `(``int` `j=0; j= r-index" makes sure that including one element ` `    ``// at index will make a combination with remaining elements ` `    ``// at remaining positions ` `    ``for` `(``int` `i=start; i<=end && end-i+1 >= r-index; i++) ` `    ``{ ` `        ``data[index] = arr[i]; ` `        ``combinationUtil(arr, data, i+1, end, index+1, r); ` `    ``} ` `} ` ` `  `// Driver program to test above functions ` `int` `main() ` `{ ` `    ``int` `arr[] = {1, 2, 3, 4, 5}; ` `    ``int` `r = 3; ` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr[0]); ` `    ``printCombination(arr, n, r); ` `} `

 `// Java program to print all combination of size r in an array of size n ` `import` `java.io.*; ` ` `  `class` `Combination { ` ` `  `    ``/* 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` `data[], ``int` `start, ` `                                ``int` `end, ``int` `index, ``int` `r) ` `    ``{ ` `        ``// Current combination is ready to be printed, print it ` `        ``if` `(index == r) ` `        ``{ ` `            ``for` `(``int` `j=``0``; j= r-index" makes sure that including one element ` `        ``// at index will make a combination with remaining elements ` `        ``// at remaining positions ` `        ``for` `(``int` `i=start; i<=end && end-i+``1` `>= r-index; i++) ` `        ``{ ` `            ``data[index] = arr[i]; ` `            ``combinationUtil(arr, data, i+``1``, end, index+``1``, r); ` `        ``} ` `    ``} ` ` `  `    ``// 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, data, ``0``, n-``1``, ``0``, r); ` `    ``} ` ` `  `    ``/*Driver function to check for above function*/` `    ``public` `static` `void` `main (String[] args) { ` `        ``int` `arr[] = {``1``, ``2``, ``3``, ``4``, ``5``}; ` `        ``int` `r = ``3``; ` `        ``int` `n = arr.length; ` `        ``printCombination(arr, n, r); ` `    ``} ` `} ` ` `  `/* This code is contributed by Devesh Agrawal */`

 `# Program to print all combination  ` `# of size r in an array of size n ` ` `  `# 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 ``=` `[``0``]``*``r; ` ` `  `    ``# Print all combination  ` `    ``# using temprary array 'data[]' ` `    ``combinationUtil(arr, data, ``0``,  ` `                    ``n ``-` `1``, ``0``, r); ` ` `  `# 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, data, start,  ` `                    ``end, index, r): ` `                         `  `    ``# Current combination is ready  ` `    ``# to be printed, print it ` `    ``if` `(index ``=``=` `r): ` `        ``for` `j ``in` `range``(r): ` `            ``print``(data[j], end ``=` `" "``); ` `        ``print``(); ` `        ``return``; ` ` `  `    ``# replace index with all ` `    ``# possible elements. The ` `    ``# condition "end-i+1 >=  ` `    ``# r-index" makes sure that  ` `    ``# including one element at ` `    ``# index will make a combination  ` `    ``# with remaining elements at  ` `    ``# remaining positions ` `    ``i ``=` `start;  ` `    ``while``(i <``=` `end ``and` `end ``-` `i ``+` `1` `>``=` `r ``-` `index): ` `        ``data[index] ``=` `arr[i]; ` `        ``combinationUtil(arr, data, i ``+` `1``,  ` `                        ``end, index ``+` `1``, r); ` `        ``i ``+``=` `1``; ` ` `  `# Driver Code ` `arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``]; ` `r ``=` `3``; ` `n ``=` `len``(arr); ` `printCombination(arr, n, r); ` ` `  `# This code is contributed by mits `

 `// 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` `[]data,  ` `                                ``int` `start, ``int` `end,  ` `                                ``int` `index, ``int` `r) ` `    ``{ ` `        ``// 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``; ` `        ``} ` ` `  `        ``// replace index with all ` `        ``// possible elements. The  ` `        ``// condition "end-i+1 >=  ` `        ``// r-index" makes sure that  ` `        ``// including one element ` `        ``// at index will make a  ` `        ``// combination with remaining  ` `        ``// elements at remaining positions ` `        ``for` `(``int` `i = start; i <= end &&  ` `                  ``end - i + 1 >= r - index; i++) ` `        ``{ ` `            ``data[index] = arr[i]; ` `            ``combinationUtil(arr, data, i + 1,  ` `                            ``end, index + 1, r); ` `        ``} ` `    ``} ` ` `  `    ``// 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, data, 0, ` `                        ``n - 1, 0, r); ` `    ``} ` ` `  `    ``// Driver Code ` `    ``static` `public` `void` `Main () ` `    ``{ ` `        ``int` `[]arr = {1, 2, 3, 4, 5}; ` `        ``int` `r = 3; ` `        ``int` `n = arr.Length; ` `        ``printCombination(arr, n, r); ` `    ``} ` `} ` ` `  `// This code is contributed by m_kit `

 ` 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 */` `function` `combinationUtil(``\$arr``, ``\$data``, ``\$start``,  ` `                         ``\$end``, ``\$index``, ``\$r``) ` `                 `  `{ ` `    ``// Current combination is ready  ` `    ``// to be printed, print it ` `    ``if` `(``\$index` `== ``\$r``) ` `    ``{ ` `        ``for` `(``\$j` `= 0; ``\$j` `< ``\$r``; ``\$j``++) ` `            ``echo` `\$data``[``\$j``]; ` `        ``echo` `"\n"``; ` `        ``return``; ` `    ``} ` ` `  `    ``// replace index with all ` `    ``// possible elements. The ` `    ``// condition "end-i+1 >=  ` `    ``// r-index" makes sure that  ` `    ``// including one element at ` `    ``// index will make a combination  ` `    ``// with remaining elements at  ` `    ``// remaining positions ` `    ``for` `(``\$i` `= ``\$start``;  ` `         ``\$i` `<= ``\$end` `&&  ` `         ``\$end` `- ``\$i` `+ 1 >= ``\$r` `- ``\$index``; ``\$i``++) ` `    ``{ ` `        ``\$data``[``\$index``] = ``\$arr``[``\$i``]; ` `        ``combinationUtil(``\$arr``, ``\$data``, ``\$i` `+ 1,  ` `                        ``\$end``, ``\$index` `+ 1, ``\$r``); ` `    ``} ` `} ` ` `  `// Driver Code ` `\$arr` `= ``array``(1, 2, 3, 4, 5); ` `\$r` `= 3; ` `\$n` `= sizeof(``\$arr``); ` `printCombination(``\$arr``, ``\$n``, ``\$r``); ` ` `  `// This code is contributed by ajit ` `?> `

Output:
```1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5```

How to handle duplicates?
Note that the above method doesn’t handle duplicates. For example, if input array is {1, 2, 1} and r is 2, then the program prints {1, 2} and {2, 1} as two different combinations. We can avoid duplicates by adding following two additional things to above code.
1) Add code to sort the array before calling combinationUtil() in printCombination()
2) Add following lines at the end of for loop in combinationUtil()

```        // Since the elements are sorted, all occurrences of an element
// must be together
while (arr[i] == arr[i+1])
i++; ```

See this for an implementation that handles duplicates.

Method 2 (Include and Exclude every element)
Like the above method, We create a temporary array data[]. 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

Following is implementation of method 2.

 `// C++ Program to print all combination of  ` `// size r in an array of size n  ` `#include ` `using` `namespace` `std; ` `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 combination is ready, print it  ` `    ``if` `(index == r)  ` `    ``{  ` `        ``for` `(``int` `j = 0; j < r; j++)  ` `            ``cout << data[j] << ``" "``;  ` `        ``cout << endl;  ` `        ``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 code  ` `int` `main()  ` `{  ` `    ``int` `arr[] = {1, 2, 3, 4, 5};  ` `    ``int` `r = 3;  ` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr[0]);  ` `    ``printCombination(arr, n, r);  ` `    ``return` `0;  ` `}  ` ` `  `// This is code is contributed by rathbhupendra `

 `// 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= 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[] = {1, 2, 3, 4, 5}; ` `    ``int` `r = 3; ` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr[0]); ` `    ``printCombination(arr, n, r); ` `    ``return` `0; ` `} `

 `// Java program to print all combination of size r in an array of size n ` `import` `java.io.*; ` ` `  `class` `Combination { ` ` `  `    ``/* 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= 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[] = {``1``, ``2``, ``3``, ``4``, ``5``}; ` `        ``int` `r = ``3``; ` `        ``int` `n = arr.length; ` `        ``printCombination(arr, n, r); ` `    ``} ` `} ` `/* This code is contributed by Devesh Agrawal */`

 `# Program to print all combination  ` `# of size r in an array of size n ` ` `  `# 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 ``=` `[``0``] ``*` `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[]     '''` `def` `combinationUtil(arr, n, r, index, data, i): ` ` `  `    ``# Current cobination is ready,  ` `    ``# 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``) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` `    ``arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``] ` `    ``r ``=` `3` `    ``n ``=` `len``(arr) ` `    ``printCombination(arr, n, r) ` ` `  `# This code is contributed  ` `# by ChitraNayal `

 `// 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 Code ` `    ``static` `public` `void` `Main () ` `    ``{ ` `        ``int` `[]arr = {1, 2, 3, 4, 5}; ` `        ``int` `r = 3; ` `        ``int` `n = arr.Length; ` `        ``printCombination(arr, n, r); ` `    ``} ` `} ` ` `  `// This code is contributed by ajit  `

 ` 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 Code ` `\$arr` `= ``array``(1, 2, 3, 4, 5); ` `\$r` `= 3; ` `\$n` `= sizeof(``\$arr``); ` `printCombination(``\$arr``, ``\$n``, ``\$r``); ` ` `  `// This code is contributed by ajit ` `?> `

Output :
```1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5```

How to handle duplicates in method 2?
Like method 1, we can following two things to handle duplicates.
1) Add code to sort the array before calling combinationUtil() in printCombination()
2) Add following lines between two recursive calls of combinationUtil() in combinationUtil()

```        // Since the elements are sorted, all occurrences of an element
// must be together
while (arr[i] == arr[i+1])
i++; ```

See this for an implementation that handles duplicates.

Below is another DFS based approach to solve this problem.
Make all combinations of size k