Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Generate all possible combinations of at most X characters from a given array

  • Last Updated : 22 Apr, 2021

Given an array arr[] consisting of N characters, the task is to generate all possible combinations of at most X elements ( 1 ≤ X ≤ N).

Examples:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: N = 3, X = 2, arr[] = {‘a’, ‘b’, ‘a’}
Output: a b c bc ca ab cb ac ba
Explanation: All possible combinations using 1 character is 3 {‘a’, ‘b’, ‘c’}. All possible combinations using 2 characters are {“bc” “ca” “ab” “cb” “ac” “ba”}.



Input: N = 3, X = 3, arr[] = {‘d’, ‘a’, ‘b’}
Output: d a b da ab bd ad ba db dab dba abd adb bda bad

Approach: The given problem can be solved using the Dynamic Programming approach. Follow the below steps to solve the problem:

  1. Generate all possible permutations that can be created with 1 character, which is the given array arr[].
  2. Store all permutations.
  3. Once stored, generate all possible permutations of 2 characters and store them.
  4. Once the last step is completed, discard all permutations of a single character.
  5. Iteratively, in the same way, calculate the permutations until X is reached.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to generate permutations of
// at most X elements from array arr[]
void differentFlagPermutations(int X,
                               vector<string> arr)
{
    vector<string> ml;
    ml = arr;
     
    for(int i = 0; i < ml.size(); i++)
    {
        cout << ml[i] << " ";
    }
 
    int count = ml.size();
   
    // Traverse all possible lengths
    for(int z = 0; z < X - 1; z++)
    {
         
        // Stores all combinations
        // of length z
        vector<string> tmp;
           
        // Traverse the array
        for(int i = 0; i < arr.size(); i++)
        {
            for(int k = 0; k < ml.size(); k++)
            {
                if (arr[i] != ml[k])
                {
                     
                    // Generate all
                    // combinations of length z
                    tmp.push_back(ml[k] + arr[i]);
                    count += 1;
                }
            }
        }    
         
        // Print all combinations of length z
        for(int i = 0; i < tmp.size(); i++)
        {
            cout << tmp[i] << " ";
        }
           
        // Replace all combinations of length z - 1
        // with all combinations of length z
        ml = tmp;
    }
}
 
// Driver Code
int main()
{
     
    // Given array
    vector<string> arr{ "c", "a", "b" };
     
    // Given X
    int X = 2;
       
    differentFlagPermutations(X, arr);
     
    return 0;
}
 
// This code is contributed by divyeshrabadiya07

Java




// Java program for the above approach
import java.util.*;
class GFG
{
 
// Function to generate permutations of
// at most X elements from array arr[]
static void differentFlagPermutations(int X,
                               String[] arr)
{
    String[] ml = arr;
     
    for(int i = 0; i < ml.length; i++)
    {
        System.out.print(ml[i] + " ");
    }
 
    int count = ml.length;
   
    // Traverse all possible lengths
    for(int z = 0; z < X - 1; z++)
    {
         
        // Stores all combinations
        // of length z
        Vector<String> tmp = new Vector<String>();
           
        // Traverse the array
        for(int i = 0; i < arr.length; i++)
        {
            for(int k = 0; k < ml.length; k++)
            {
                if (arr[i] != ml[k])
                {
                     
                    // Generate all
                    // combinations of length z
                    tmp.add(ml[k] + arr[i]);
                    count += 1;
                }
            }
        }    
         
        // Print all combinations of length z
        for(int i = 0; i < tmp.size(); i++)
        {
            System.out.print(tmp.get(i) + " ");
        }
           
        // Replace all combinations of length z - 1
        // with all combinations of length z
        ml = tmp.toArray(new String[tmp.size()]);;
    }
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given array
    String []arr = { "c", "a", "b" };
     
    // Given X
    int X = 2;     
    differentFlagPermutations(X, arr);  
}
}
 
// This code is contributed by shikhasingrajput

Python3




# Python3 program for the above approach
 
# Function to generate permutations of
# at most X elements from array arr[]
def differentFlagPermutations(X, arr):
 
    ml = arr.copy()
 
    print(" ".join(ml), end =" ")
    count = len(ml)
 
    # Traverse all possible lengths
    for z in range(X-1):
         
        # Stores all combinations
        # of length z
        tmp = []
         
        # Traverse the array
        for i in arr:
            for k in ml:
                if i not in k:
                     
                    # Generate all
                    # combinations of length z
                    tmp.append(k + i)
                    count += 1
                     
        # Print all combinations of length z
        print(" ".join(tmp), end =" ")
         
        # Replace all combinations of length z - 1
        # with all combinations of length z
        ml = tmp
 
 
# Given array
arr = ['c', 'a', 'b']
 
# Given X
X = 2
 
differentFlagPermutations(X, arr)

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG
{
 
  // Function to generate permutations of
  // at most X elements from array arr[]
  static void differentFlagPermutations(int X, List<string> arr)
  {
    List<string> ml = new List<string>();
    ml = arr;
    for(int i = 0; i < ml.Count; i++)
    {
      Console.Write(ml[i] + " ");
    }
 
    int count = ml.Count;
 
    // Traverse all possible lengths
    for(int z = 0; z < X - 1; z++)
    {
 
      // Stores all combinations
      // of length z
      List<string> tmp = new List<string>();
 
      // Traverse the array
      for(int i = 0; i < arr.Count; i++)
      {
        for(int k = 0; k < ml.Count; k++)
        {
          if (arr[i] != ml[k])
          {
 
            // Generate all
            // combinations of length z
            tmp.Add(ml[k] + arr[i]);
            count += 1;
          }
        }
      }    
 
      // Print all combinations of length z
      for(int i = 0; i < tmp.Count; i++)
      {
        Console.Write(tmp[i] + " ");
      }
 
      // Replace all combinations of length z - 1
      // with all combinations of length z
      ml = tmp;
    }
  }
 
  // Driver code
  static void Main()
  {
     
    // Given array
    List<string> arr = new List<string>(new string[] { "c", "a", "b" });
 
    // Given X
    int X = 2;
 
    differentFlagPermutations(X, arr);
  }
}
 
// This code is contributed by divyesh072019

Javascript




<script>
 
    // Javascript program for the above approach
     
    // Function to generate permutations of
    // at most X elements from array arr[]
    function differentFlagPermutations(X, arr)
    {
      let ml = [];
      ml = arr;
      for(let i = 0; i < ml.length; i++)
      {
        document.write(ml[i] + " ");
      }
 
      let count = ml.length;
 
      // Traverse all possible lengths
      for(let z = 0; z < X - 1; z++)
      {
 
        // Stores all combinations
        // of length z
        let tmp = [];
 
        // Traverse the array
        for(let i = 0; i < arr.length; i++)
        {
          for(let k = 0; k < ml.length; k++)
          {
            if (arr[i] != ml[k])
            {
 
              // Generate all
              // combinations of length z
              tmp.push(ml[k] + arr[i]);
              count += 1;
            }
          }
        }   
 
        // Print all combinations of length z
        for(let i = 0; i < tmp.length; i++)
        {
          document.write(tmp[i] + " ");
        }
 
        // Replace all combinations of length z - 1
        // with all combinations of length z
        ml = tmp;
      }
    }
     
    // Given array
    let arr = [ "c", "a", "b" ];
  
    // Given X
    let X = 2;
  
    differentFlagPermutations(X, arr);
 
</script>
Output: 
c a b ac bc ca ba cb ab

 

Time Complexity: O(X*N2)
Auxiliary Space: O(N2)




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!