All combinations of size r from an array
Last Updated : 23 Apr, 2025
Improve
You are given an array arr[] consisting of n elements. Your task is to generate and print all possible combinations of exactly r elements from this array.
Note: A combination is a selection of items where the order does not matter. Ensure that each unique group of r elements is printed only once, regardless of order.
Example:
Input: arr = [1, 2, 3, 4], r = 2
Output: 1 2
1 3
1 4
2 3
2 4
3 4
Explanation: We need to generate all possible combinations of size 2 from an array of size 4. The total number of such combinations is given by the formula:
4C2 = 4! / [(4 – 2)! × 2!] = 6 combinations.Input: arr = [1, 2, 3, 4], r = 3
Output: 1 2 3
1 2 4
1 3 4
2 3 4
Explanation: We need to generate all possible combinations of size 3 from an array of size 4. The total number of such combinations is given by the formula:
4C3 = 4! / [(4 – 3)! × 3!] = 4 combinations.
Using Recursion and Fixing The Elements – O(nCr) Time and O(r) Space
The idea is to fix one element at a time at the current index and recursively fill the remaining positions. Starting from the first index, we try all possible elements that can be placed at that position such that the remaining elements can still fill the combination of size r. Once the size of the current combination becomes equal to r, we store or print that combination. To avoid duplicates, we only consider elements for the remaining positions that are on the right side of the current element.
Follow the below given step-by-step approach:
- Start with the first index (initially 0) and fix one element at this index.
- Recursively try to fix the next element at the next index.
- Continue this process until the size of the current combination becomes equal to
r. - At each recursive call, iterate from the current
startindex to theendof the array while ensuring there are enough remaining elements to fill the combination. - When the current combination size becomes
r, add it to the result list. - Use a temporary array to build each combination step by step.
- Store the final combinations in a result list and return it.
Following diagram shows recursion tree:
Below is given the implementation:
#include <bits/stdc++.h>
using namespace std;
// Helper function to find all combinations
// of size r in an array of size n
void combinationUtil(int ind, int r, vector<int> &data,
vector<vector<int>> &result, vector<int> &arr) {
int n = arr.size();
// If size of current combination is r
if (data.size() == r) {
result.push_back(data);
return;
}
// Replace index with all possible elements
for(int i = ind; i < n; i++) {
// Current element is included
data.push_back(arr[i]);
// Recur for next elements
combinationUtil(i + 1, r, data, result, arr);
// Backtrack to find other combinations
data.pop_back();
}
}
// Function to find all combinations of size r
// in an array of size n
vector<vector<int>> findCombination(vector<int> &arr, int r) {
int n = arr.size();
// to store the result
vector<vector<int>> result;
// Temporary array to store current combination
vector<int> data;
combinationUtil(0, r, data, result, arr);
return result;
}
int main() {
vector<int> arr = {1, 2, 3, 4};
int r = 2;
vector<vector<int>> res = findCombination(arr, r);
for (const auto &comb : res) {
for (int num : comb) {
cout << num << " ";
}
cout << endl;
}
return 0;
}
import java.util.*;
class GfG {
// Helper function to find all combinations
// of size r in an array of size n
static void combinationUtil(int ind, int r, List<Integer> data,
List<List<Integer>> result, int[] arr) {
int n = arr.length;
// If size of current combination is r
if (data.size() == r) {
result.add(new ArrayList<>(data));
return;
}
// Replace index with all possible elements
for (int i = ind; i < n; i++) {
// Current element is included
data.add(arr[i]);
// Recur for next elements
combinationUtil(i + 1, r, data, result, arr);
// Backtrack to find other combinations
data.remove(data.size() - 1);
}
}
// Function to find all combinations of size r
// in an array of size n
static List<List<Integer>> findCombination(int[] arr, int r) {
int n = arr.length;
// to store the result
List<List<Integer>> result = new ArrayList<>();
// Temporary array to store current combination
List<Integer> data = new ArrayList<>();
combinationUtil(0, r, data, result, arr);
return result;
}
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4};
int r = 2;
List<List<Integer>> res = findCombination(arr, r);
for (List<Integer> comb : res) {
for (int num : comb) {
System.out.print(num + " ");
}
System.out.println();
}
}
}
# Helper function to find all combinations
# of size r in an array of size n
def combinationUtil(ind, r, data, result, arr):
n = len(arr)
# If size of current combination is r
if len(data) == r:
result.append(data.copy())
return
# Replace index with all possible elements
for i in range(ind, n):
# Current element is included
data.append(arr[i])
# Recur for next elements
combinationUtil(i + 1, r, data, result, arr)
# Backtrack to find other combinations
data.pop()
# Function to find all combinations of size r
# in an array of size n
def findCombination(arr, r):
n = len(arr)
# to store the result
result = []
# Temporary array to store current combination
data = []
combinationUtil(0, r, data, result, arr)
return result
arr = [1, 2, 3, 4]
r = 2
res = findCombination(arr, r)
for comb in res:
for num in comb:
print(num, end=" ")
print()
using System;
using System.Collections.Generic;
class GfG {
// Helper function to find all combinations
// of size r in an array of size n
static void combinationUtil(int ind, int r, List<int> data,
List<List<int>> result, int[] arr) {
int n = arr.Length;
// If size of current combination is r
if (data.Count == r) {
result.Add(new List<int>(data));
return;
}
// Replace index with all possible elements
for (int i = ind; i < n; i++) {
// Current element is included
data.Add(arr[i]);
// Recur for next elements
combinationUtil(i + 1, r, data, result, arr);
// Backtrack to find other combinations
data.RemoveAt(data.Count - 1);
}
}
// Function to find all combinations of size r
// in an array of size n
static List<List<int>> findCombination(int[] arr, int r) {
int n = arr.Length;
// to store the result
List<List<int>> result = new List<List<int>>();
// Temporary array to store current combination
List<int> data = new List<int>();
combinationUtil(0, r, data, result, arr);
return result;
}
static void Main() {
int[] arr = {1, 2, 3, 4};
int r = 2;
List<List<int>> res = findCombination(arr, r);
foreach (var comb in res) {
foreach (int num in comb) {
Console.Write(num + " ");
}
Console.WriteLine();
}
}
}
// Helper function to find all combinations
// of size r in an array of size n
function combinationUtil(ind, r, data, result, arr) {
const n = arr.length;
// If size of current combination is r
if (data.length === r) {
result.push([...data]);
return;
}
// Replace index with all possible elements
for (let i = ind; i < n; i++) {
// Current element is included
data.push(arr[i]);
// Recur for next elements
combinationUtil(i + 1, r, data, result, arr);
// Backtrack to find other combinations
data.pop();
}
}
// Function to find all combinations of size r
// in an array of size n
function findCombination(arr, r) {
const n = arr.length;
// to store the result
const result = [];
// Temporary array to store current combination
const data = [];
combinationUtil(0, r, data, result, arr);
return result;
}
const arr = [1, 2, 3, 4];
const r = 2;
const res = findCombination(arr, r);
for (const comb of res) {
for (const num of comb) {
process.stdout.write(num + " ");
}
console.log();
}
Output
1 2 1 3 1 4 2 3 2 4 3 4
Using Recursion and Including – Excluding Each Element – O(2 ^ n) Time and O(r) Space
The idea is to explore each element in the array by making a binary choice—either include it in the current combination or skip it—while keeping track of the elements chosen so far. We recursively advance through the array, adding elements until the temporary combination reaches size r (at which point it’s recorded), then backtrack to explore all other possibilities. This guarantees that every valid combination of size r is generated.
Follow the below given step-by-step approach:
- Initialize an empty list
datato hold the current combination. - Define a recursive function with parameters
(ind, r, data, result, arr). - If
data.size() == r, add a copy ofdatatoresultand return. - If
ind >= arr.size(), return (no more elements to process). - Add
arr[ind]todata. - Recurse with
ind + 1to include the current element. - Remove the last element from
data(backtrack). - Recurse with
ind + 1to explore combinations that exclude the current element.
Below is given the implementation:
#include <bits/stdc++.h>
using namespace std;
// Helper function to find all combinations
// of size r in an array of size n
void combinationUtil(int ind, int r, vector<int> &data,
vector<vector<int>> &result, vector<int> &arr) {
int n = arr.size();
// If size of current combination is r
if (data.size() == r) {
result.push_back(data);
return;
}
// If no more elements are left to put in data
if (ind >= n) {
return;
}
// include the current element
data.push_back(arr[ind]);
// Recur for next elements
combinationUtil(ind + 1, r, data, result, arr);
// Backtrack to find other combinations
data.pop_back();
// exclude the current element and move to the next
combinationUtil(ind + 1, r, data, result, arr);
}
// Function to find all combinations of size r
// in an array of size n
vector<vector<int>> findCombination(vector<int> &arr, int r) {
int n = arr.size();
// to store the result
vector<vector<int>> result;
// Temporary array to store current combination
vector<int> data;
combinationUtil(0, r, data, result, arr);
return result;
}
int main() {
vector<int> arr = {1, 2, 3, 4};
int r = 2;
vector<vector<int>> res = findCombination(arr, r);
for (const auto &comb : res) {
for (int num : comb) {
cout << num << " ";
}
cout << endl;
}
return 0;
}
import java.util.*;
class GfG {
// Helper function to find all combinations
// of size r in an array of size n
static void combinationUtil(int ind, int r, List<Integer> data,
List<List<Integer>> result, int[] arr) {
int n = arr.length;
// If size of current combination is r
if (data.size() == r) {
result.add(new ArrayList<>(data));
return;
}
// If no more elements are left to put in data
if (ind >= n) {
return;
}
// include the current element
data.add(arr[ind]);
// Recur for next elements
combinationUtil(ind + 1, r, data, result, arr);
// Backtrack to find other combinations
data.remove(data.size() - 1);
// exclude the current element and move to the next
combinationUtil(ind + 1, r, data, result, arr);
}
// Function to find all combinations of size r
// in an array of size n
static List<List<Integer>> findCombination(int[] arr, int r) {
int n = arr.length;
// to store the result
List<List<Integer>> result = new ArrayList<>();
// Temporary array to store current combination
List<Integer> data = new ArrayList<>();
combinationUtil(0, r, data, result, arr);
return result;
}
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4};
int r = 2;
List<List<Integer>> res = findCombination(arr, r);
for (List<Integer> comb : res) {
for (int num : comb) {
System.out.print(num + " ");
}
System.out.println();
}
}
}
# Helper function to find all combinations
# of size r in an array of size n
def combinationUtil(ind, r, data,
result, arr):
n = len(arr)
# If size of current combination is r
if len(data) == r:
result.append(data.copy())
return
# If no more elements are left to put in data
if ind >= n:
return
# include the current element
data.append(arr[ind])
# Recur for next elements
combinationUtil(ind + 1, r, data, result, arr)
# Backtrack to find other combinations
data.pop()
# exclude the current element and move to the next
combinationUtil(ind + 1, r, data, result, arr)
# Function to find all combinations of size r
# in an array of size n
def findCombination(arr, r):
n = len(arr)
# to store the result
result = []
# Temporary array to store current combination
data = []
combinationUtil(0, r, data, result, arr)
return result
arr = [1, 2, 3, 4]
r = 2
res = findCombination(arr, r)
for comb in res:
for num in comb:
print(num, end=" ")
print()
using System;
using System.Collections.Generic;
class GfG {
// Helper function to find all combinations
// of size r in an array of size n
static void combinationUtil(int ind, int r, List<int> data,
List<List<int>> result, int[] arr) {
int n = arr.Length;
// If size of current combination is r
if (data.Count == r) {
result.Add(new List<int>(data));
return;
}
// If no more elements are left to put in data
if (ind >= n) {
return;
}
// include the current element
data.Add(arr[ind]);
// Recur for next elements
combinationUtil(ind + 1, r, data, result, arr);
// Backtrack to find other combinations
data.RemoveAt(data.Count - 1);
// exclude the current element and move to the next
combinationUtil(ind + 1, r, data, result, arr);
}
// Function to find all combinations of size r
// in an array of size n
static List<List<int>> findCombination(int[] arr, int r) {
int n = arr.Length;
// to store the result
List<List<int>> result = new List<List<int>>();
// Temporary array to store current combination
List<int> data = new List<int>();
combinationUtil(0, r, data, result, arr);
return result;
}
static void Main() {
int[] arr = {1, 2, 3, 4};
int r = 2;
List<List<int>> res = findCombination(arr, r);
foreach (var comb in res) {
foreach (int num in comb) {
Console.Write(num + " ");
}
Console.WriteLine();
}
}
}
// Helper function to find all combinations
// of size r in an array of size n
function combinationUtil(ind, r, data, result, arr) {
const n = arr.length;
// If size of current combination is r
if (data.length === r) {
result.push([...data]);
return;
}
// If no more elements are left to put in data
if (ind >= n) {
return;
}
// include the current element
data.push(arr[ind]);
// Recur for next elements
combinationUtil(ind + 1, r, data, result, arr);
// Backtrack to find other combinations
data.pop();
// exclude the current element and move to the next
combinationUtil(ind + 1, r, data, result, arr);
}
// Function to find all combinations of size r
// in an array of size n
function findCombination(arr, r) {
const n = arr.length;
// to store the result
const result = [];
// Temporary array to store current combination
const data = [];
combinationUtil(0, r, data, result, arr);
return result;
}
const arr = [1, 2, 3, 4];
const r = 2;
const res = findCombination(arr, r);
for (const comb of res) {
for (const num of comb) {
process.stdout.write(num + " ");
}
console.log();
}
Output
1 2 1 3 1 4 2 3 2 4 3 4
Using Sort to Handle The Duplicate Elements in Input – O(2 ^ n) Time and O(n) Space
The idea is to eliminate duplicate combinations by first sorting the input array so that identical elements are adjacent, and then, during the recursive generation, skipping any element that is the same as its immediate predecessor at the same recursion depth. This ensures that each unique value is only considered once per position in the combination, preventing repeated outputs.
Follow the below given step-by-step approach:
- Sort the input array before invoking the recursive routine.
- In the recursive helper, iterate
ifromindton–1. - If
i > indandarr[i] == arr[i–1], skip this iteration to avoid duplicates. - Include
arr[i]in the current combination list and recurse withind = i + 1. - Backtrack by removing the last element after the recursive call.
- Continue recursion to consider combinations that exclude
arr[i]. - Whenever the current combination’s size reaches
r, add it to the result.
Below is given the implementation:
#include <bits/stdc++.h>
using namespace std;
// Helper function to find all combinations
// of size r in an array of size n
void combinationUtil(int ind, int r, vector<int> &data,
vector<vector<int>> &result, vector<int> &arr) {
int n = arr.size();
// If size of current combination is r
if (data.size() == r) {
result.push_back(data);
return;
}
// If no more elements are left to put in data
if (ind >= n) {
return;
}
// include the current element
data.push_back(arr[ind]);
// Recur for next elements
combinationUtil(ind + 1, r, data, result, arr);
// Backtrack to find other combinations
data.pop_back();
// exclude the current element and
// move to the next unique element
while(ind + 1 < n && arr[ind] == arr[ind + 1]) {
ind++;
}
combinationUtil(ind + 1, r, data, result, arr);
}
// Function to find all combinations of size r
// in an array of size n
vector<vector<int>> findCombination(vector<int> &arr, int r) {
int n = arr.size();
// to store the result
vector<vector<int>> result;
// sort the array
sort(arr.begin(), arr.end());
// Temporary array to store current combination
vector<int> data;
combinationUtil(0, r, data, result, arr);
return result;
}
int main() {
vector<int> arr = {1, 1, 2, 3, 4};
int r = 2;
vector<vector<int>> res = findCombination(arr, r);
for (const auto &comb : res) {
for (int num : comb) {
cout << num << " ";
}
cout << endl;
}
return 0;
}
import java.util.*;
class GfG {
// Helper function to find all combinations
// of size r in an array of size n
static void combinationUtil(int ind, int r, List<Integer> data,
List<List<Integer>> result, int[] arr) {
int n = arr.length;
// If size of current combination is r
if (data.size() == r) {
result.add(new ArrayList<>(data));
return;
}
// If no more elements are left to put in data
if (ind >= n) {
return;
}
// include the current element
data.add(arr[ind]);
// Recur for next elements
combinationUtil(ind + 1, r, data, result, arr);
// Backtrack to find other combinations
data.remove(data.size() - 1);
// exclude the current element and
// move to the next unique element
while (ind + 1 < n && arr[ind] == arr[ind + 1]) {
ind++;
}
combinationUtil(ind + 1, r, data, result, arr);
}
// Function to find all combinations of size r
// in an array of size n
static List<List<Integer>> findCombination(int[] arr, int r) {
int n = arr.length;
// to store the result
List<List<Integer>> result = new ArrayList<>();
// sort the array
Arrays.sort(arr);
// Temporary array to store current combination
List<Integer> data = new ArrayList<>();
combinationUtil(0, r, data, result, arr);
return result;
}
public static void main(String[] args) {
int[] arr = {1, 1, 2, 3, 4};
int r = 2;
List<List<Integer>> res = findCombination(arr, r);
for (List<Integer> comb : res) {
for (int num : comb) {
System.out.print(num + " ");
}
System.out.println();
}
}
}
# Helper function to find all combinations
# of size r in an array of size n
def combinationUtil(ind, r, data,
result, arr):
n = len(arr)
# If size of current combination is r
if len(data) == r:
result.append(data.copy())
return
# If no more elements are left to put in data
if ind >= n:
return
# include the current element
data.append(arr[ind])
# Recur for next elements
combinationUtil(ind + 1, r, data, result, arr)
# Backtrack to find other combinations
data.pop()
# exclude the current element and
# move to the next unique element
while ind + 1 < n and arr[ind] == arr[ind + 1]:
ind += 1
combinationUtil(ind + 1, r, data, result, arr)
# Function to find all combinations of size r
# in an array of size n
def findCombination(arr, r):
n = len(arr)
# to store the result
result = []
# sort the array
arr.sort()
# Temporary array to store current combination
data = []
combinationUtil(0, r, data, result, arr)
return result
arr = [1, 1, 2, 3, 4]
r = 2
res = findCombination(arr, r)
for comb in res:
for num in comb:
print(num, end=" ")
print()
using System;
using System.Collections.Generic;
class GfG {
// Helper function to find all combinations
// of size r in an array of size n
static void combinationUtil(int ind, int r, List<int> data,
List<List<int>> result, int[] arr) {
int n = arr.Length;
// If size of current combination is r
if (data.Count == r) {
result.Add(new List<int>(data));
return;
}
// If no more elements are left to put in data
if (ind >= n) {
return;
}
// include the current element
data.Add(arr[ind]);
// Recur for next elements
combinationUtil(ind + 1, r, data, result, arr);
// Backtrack to find other combinations
data.RemoveAt(data.Count - 1);
// exclude the current element and
// move to the next unique element
while (ind + 1 < n && arr[ind] == arr[ind + 1]) {
ind++;
}
combinationUtil(ind + 1, r, data, result, arr);
}
// Function to find all combinations of size r
// in an array of size n
static List<List<int>> findCombination(int[] arr, int r) {
int n = arr.Length;
// to store the result
List<List<int>> result = new List<List<int>>();
// sort the array
Array.Sort(arr);
// Temporary array to store current combination
List<int> data = new List<int>();
combinationUtil(0, r, data, result, arr);
return result;
}
static void Main() {
int[] arr = {1, 1, 2, 3, 4};
int r = 2;
List<List<int>> res = findCombination(arr, r);
foreach (var comb in res) {
foreach (int num in comb) {
Console.Write(num + " ");
}
Console.WriteLine();
}
}
}
// Helper function to find all combinations
// of size r in an array of size n
function combinationUtil(ind, r, data, result, arr) {
const n = arr.length;
// If size of current combination is r
if (data.length === r) {
result.push([...data]);
return;
}
// If no more elements are left to put in data
if (ind >= n) {
return;
}
// include the current element
data.push(arr[ind]);
// Recur for next elements
combinationUtil(ind + 1, r, data, result, arr);
// Backtrack to find other combinations
data.pop();
// exclude the current element and
// move to the next unique element
while (ind + 1 < n && arr[ind] === arr[ind + 1]) {
ind++;
}
combinationUtil(ind + 1, r, data, result, arr);
}
// Function to find all combinations of size r
// in an array of size n
function findCombination(arr, r) {
const n = arr.length;
// to store the result
const result = [];
// sort the array
arr.sort((a, b) => a - b);
// Temporary array to store current combination
const data = [];
combinationUtil(0, r, data, result, arr);
return result;
}
const arr = [1, 1, 2, 3, 4];
const r = 2;
const res = findCombination(arr, r);
for (const comb of res) {
for (const num of comb) {
process.stdout.write(num + " ");
}
console.log();
}
Output
1 1 1 2 1 3 1 4 2 3 2 4 3 4
