Iterative approach to print all combinations of an Array
Last Updated :
24 Jan, 2023
Given an array arr[] of size N, the task is to generate and print all possible combinations of R elements in array. Examples:
Input: arr[] = {0, 1, 2, 3}, R = 3 Output: 0 1 2 0 1 3 0 2 3 1 2 3 Input: arr[] = {1, 3, 4, 5, 6, 7}, R = 5 Output: 1 3 4 5 6 1 3 4 5 7 1 3 4 6 7 1 3 5 6 7 1 4 5 6 7 3 4 5 6 7
Approach: Recursive methods are discussed here. In this post, an iterative method to output all combinations for a given array will be discussed. The iterative method acts as a state machine. When the machine is called, it outputs a combination and move to the next one. For a combination of r elements from an array of size n, a given element may be included or excluded from the combination. Let’s have a Boolean array of size n to label whether the corresponding element in data array is included. If the ith element in the data array is included, then the ith element in the boolean array is true or false otherwise. Then, r booleans in the boolean array will be labelled as true. We can initialize the boolean array to have r trues from index 0 to index r – 1. During the iteration, we scan the boolean array from left to right and find the first element which is true and whose previous one is false and the first element which is true and whose next one is false. Then, we have the first continuous tract of trues in the Boolean array. Assume there are m trues in this tract, starting from index Start and ending at index End. The next iteration would be
- Set index End + 1 of the boolean array to true.
- Set index Start to index End – 1 of the boolean array to false.
- Set index 0 to index k – 2 to true.
For example, If the current boolean array is {0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0}, then k = 4, Start = 2, and End = 5. The next Boolean array would be {1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0}. In case Start == End where there is only one true in the tract, we simply set index End to false and index End + 1 to true. We also need to record the current Start and End and update Start and End during each iteration. When the last r booleans are set to true, we cannot move to the next combination and we stop. The following image illustrates how the boolean array changes from one iteration to another. To output the combination, we just scan the boolean array. If its ith index is true, we print out the ith element of the data array. Below is the implementation of the above approach:
C++
#include <iostream>
using namespace std;
class Combination {
private :
int * Indices;
int N;
int R;
bool * Flags;
int Start;
int End;
public :
Combination( int * arr, int n, int r)
{
this ->Indices = arr;
this ->N = n;
this ->R = r;
this ->Flags = nullptr;
}
~Combination()
{
if ( this ->Flags != nullptr) {
delete [] this ->Flags;
}
}
void GetFirst()
{
this ->Flags = new bool [N];
for ( int i = 0; i < this ->N; ++i) {
if (i < this ->R) {
Flags[i] = true ;
}
else {
Flags[i] = false ;
}
}
this ->Start = 0;
this ->End = this ->R - 1;
this ->Output();
}
bool HasNext()
{
return End < ( this ->N - 1);
}
void Next()
{
if ( this ->Start == this ->End) {
this ->Flags[ this ->End] = false ;
this ->Flags[ this ->End + 1] = true ;
this ->Start += 1;
this ->End += 1;
while ( this ->End + 1 < this ->N
&& this ->Flags[ this ->End + 1]) {
++ this ->End;
}
}
else {
if ( this ->Start == 0) {
Flags[ this ->End] = false ;
Flags[ this ->End + 1] = true ;
this ->End -= 1;
}
else {
Flags[ this ->End + 1] = true ;
for ( int i = this ->Start; i <= this ->End; ++i) {
Flags[i] = false ;
}
for ( int i = 0; i < this ->End - this ->Start; ++i) {
Flags[i] = true ;
}
this ->End = this ->End - this ->Start - 1;
this ->Start = 0;
}
}
this ->Output();
}
private :
void Output()
{
for ( int i = 0, count = 0; i < this ->N
&& count < this ->R;
++i) {
if (Flags[i]) {
cout << Indices[i] << " " ;
++count;
}
}
cout << endl;
}
};
int main()
{
int arr[] = { 0, 1, 2, 3 };
int n = sizeof (arr) / sizeof ( int );
int r = 3;
Combination com(arr, n, r);
com.GetFirst();
while (com.HasNext()) {
com.Next();
}
return 0;
}
|
Java
class Combination
{
private int [] Indices;
private int R;
private boolean [] Flags;
private int Start;
private int End;
public Combination( int [] arr, int r)
{
this .Indices = arr;
this .R = r;
}
public void GetFirst()
{
Flags = new boolean [ this .Indices.length];
for ( int i = 0 ; i < this .R; ++i)
{
Flags[i] = true ;
}
this .Start = 0 ;
this .End = this .R - 1 ;
this .Output();
}
public boolean HasNext()
{
return End < ( this .Indices.length - 1 );
}
public void Next()
{
if ( this .Start == this .End)
{
this .Flags[ this .End] = false ;
this .Flags[ this .End + 1 ] = true ;
this .Start += 1 ;
this .End += 1 ;
while ( this .End + 1 < this .Indices.length
&& this .Flags[ this .End + 1 ])
{
++ this .End;
}
}
else
{
if ( this .Start == 0 )
{
Flags[ this .End] = false ;
Flags[ this .End + 1 ] = true ;
this .End -= 1 ;
}
else
{
Flags[ this .End + 1 ] = true ;
for ( int i = this .Start; i <= this .End; ++i)
{
Flags[i] = false ;
}
for ( int i = 0 ; i < this .End - this .Start; ++i)
{
Flags[i] = true ;
}
this .End = this .End - this .Start - 1 ;
this .Start = 0 ;
}
}
this .Output();
}
private void Output()
{
for ( int i = 0 , count = 0 ; i < Indices.length
&& count < this .R; ++i)
{
if (Flags[i])
{
System.out.print(Indices[i]);
System.out.print( " " );
++count;
}
}
System.out.println();
}
}
class GFG
{
public static void main(String[] args)
{
int [] arr = { 0 , 1 , 2 , 3 };
int r = 3 ;
Combination com = new Combination(arr, r);
com.GetFirst();
while (com.HasNext())
{
com.Next();
}
}
}
|
Python3
class Combination :
Indices = None
R = 0
Flags = None
Start = 0
End = 0
def __init__( self , arr, r) :
self .Indices = arr
self .R = r
def GetFirst( self ) :
self .Flags = [ False ] * ( len ( self .Indices))
i = 0
while (i < self .R) :
self .Flags[i] = True
i + = 1
self .Start = 0
self .End = self .R - 1
self .Output()
def HasNext( self ) :
return self .End < ( len ( self .Indices) - 1 )
def Next ( self ) :
if ( self .Start = = self .End) :
self .Flags[ self .End] = False
self .Flags[ self .End + 1 ] = True
self .Start + = 1
self .End + = 1
while ( self .End + 1 < len ( self .Indices) and self .Flags[ self .End + 1 ]) :
self .End + = 1
else :
if ( self .Start = = 0 ) :
self .Flags[ self .End] = False
self .Flags[ self .End + 1 ] = True
self .End - = 1
else :
self .Flags[ self .End + 1 ] = True
i = self .Start
while (i < = self .End) :
self .Flags[i] = False
i + = 1
i = 0
while (i < self .End - self .Start) :
self .Flags[i] = True
i + = 1
self .End = self .End - self .Start - 1
self .Start = 0
self .Output()
def Output( self ) :
i = 0
count = 0
while (i < len ( self .Indices) and count < self .R) :
if ( self .Flags[i]) :
print ( self .Indices[i], end = "")
print ( " " , end = "")
count + = 1
i + = 1
print ()
class GFG :
@staticmethod
def main( args) :
arr = [ 0 , 1 , 2 , 3 ]
r = 3
com = Combination(arr, r)
com.GetFirst()
while (com.HasNext()) :
com. Next ()
if __name__ = = "__main__" :
GFG.main([])
|
C#
using System;
namespace IterativeCombination {
class Combination {
private int [] Indices;
private int R;
private bool [] Flags;
private int Start;
private int End;
public Combination( int [] arr, int r)
{
this .Indices = arr;
this .R = r;
}
public void GetFirst()
{
Flags = new bool [ this .Indices.Length];
for ( int i = 0; i < this .R; ++i) {
Flags[i] = true ;
}
this .Start = 0;
this .End = this .R - 1;
this .Output();
}
public bool HasNext()
{
return End < ( this .Indices.Length - 1);
}
public void Next()
{
if ( this .Start == this .End) {
this .Flags[ this .End] = false ;
this .Flags[ this .End + 1] = true ;
this .Start += 1;
this .End += 1;
while ( this .End + 1 < this .Indices.Length
&& this .Flags[ this .End + 1]) {
++ this .End;
}
}
else {
if ( this .Start == 0) {
Flags[ this .End] = false ;
Flags[ this .End + 1] = true ;
this .End -= 1;
}
else {
Flags[ this .End + 1] = true ;
for ( int i = this .Start; i <= this .End; ++i) {
Flags[i] = false ;
}
for ( int i = 0; i < this .End - this .Start; ++i) {
Flags[i] = true ;
}
this .End = this .End - this .Start - 1;
this .Start = 0;
}
}
this .Output();
}
private void Output()
{
for ( int i = 0, count = 0; i < Indices.Length
&& count < this .R;
++i) {
if (Flags[i]) {
Console.Write(Indices[i]);
Console.Write( " " );
++count;
}
}
Console.WriteLine();
}
}
class AppDriver {
static void Main()
{
int [] arr = { 0, 1, 2, 3 };
int r = 3;
Combination com = new Combination(arr, r);
com.GetFirst();
while (com.HasNext()) {
com.Next();
}
}
}
}
|
Javascript
class Combination {
Indices = null ;
R = 0;
Flags = null ;
Start = 0;
End = 0;
constructor(arr, r) {
this .Indices = arr;
this .R = r;
}
GetFirst() {
this .Flags = Array( this .Indices.length).fill( false );
let i = 0;
while (i < this .R) {
this .Flags[i] = true ;
i += 1;
}
this .Start = 0;
this .End = this .R - 1;
this .Output();
}
HasNext() {
return this .End < ( this .Indices.length - 1);
}
Next() {
if ( this .Start === this .End) {
this .Flags[ this .End] = false ;
this .Flags[ this .End + 1] = true ;
this .Start += 1;
this .End += 1;
while ( this .End + 1 < this .Indices.length && this .Flags[ this .End + 1]) {
this .End += 1;
}
} else {
if ( this .Start === 0) {
this .Flags[ this .End] = false ;
this .Flags[ this .End + 1] = true ;
this .End -= 1;
} else {
this .Flags[ this .End + 1] = true ;
let i = this .Start;
while (i <= this .End) {
this .Flags[i] = false ;
i += 1;
}
i = 0;
while (i < this .End - this .Start) {
this .Flags[i] = true ;
i += 1;
}
this .End = this .End - this .Start - 1;
this .Start = 0;
}
this .Output();
}
}
Output() {
let i = 0;
let count = 0;
while (i < this .Indices.length && count < this .R) {
if ( this .Flags[i]) {
document.write( this .Indices[i], " " );
count += 1;
}
i += 1;
}
document.write( "<br>" );
}
}
class GFG {
static main() {
let arr = [0, 1, 2, 3];
let r = 3;
let com = new Combination(arr, r);
com.GetFirst();
while (com.HasNext()) {
com.Next();
}
}
}
if (require.main === module) {
GFG.main();
}
|
Javascript
class Combination {
Indices = null ;
R = 0;
Flags = null ;
Start = 0;
End = 0;
constructor(arr, r) {
this .Indices = arr;
this .R = r;
}
GetFirst() {
this .Flags = Array( this .Indices.length).fill( false );
for (let i = 0; i < this .R; i++) {
this .Flags[i] = true ;
}
this .Start = 0;
this .End = this .R - 1;
this .Output();
}
HasNext() {
return this .End < ( this .Indices.length - 1);
}
Next()
{
if ( this .Start === this .End) {
this .Flags[ this .End] = false ;
this .Flags[ this .End + 1] = true ;
this .Start += 1;
this .End += 1;
while ( this .End + 1 < this .Indices.length && this .Flags[ this .End + 1]) {
this .End += 1;
}
}
else
{
if ( this .Start === 0) {
this .Flags[ this .End] = false ;
this .Flags[ this .End + 1] = true ;
this .End -= 1;
} else {
this .Flags[ this .End + 1] = true ;
for (let i = this .Start; i <= this .End; i++) {
this .Flags[i] = false ;
}
for (let i = 0; i < this .End - this .Start; i++) {
this .Flags[i] = true ;
}
this .End = this .End - this .Start - 1;
this .Start = 0;
}
}
this .Output();
}
Output() {
for (let i = 0, count = 0; i < this .Indices.length && count < this .R; i++)
{
if ( this .Flags[i]) {
console.log( this .Indices[i], " " );
count += 1;
}
}
console.log( "<br>" );
}
}
class GFG {
static main() {
let arr = [0, 1, 2, 3];
let r = 3;
let com = new Combination(arr, r);
com.GetFirst();
while (com.HasNext()) {
com.Next();
}
}
}
if (require.main === module) {
GFG.main();
}
|
Output:
0 1 2
0 1 3
0 2 3
1 2 3
Share your thoughts in the comments
Please Login to comment...