Check if a given string can be formed by two other strings or their permutations

A string is a continuous stream of characters, numbers. It may even contain special characters. An string can be composed of multiple sub-strings, also referred by words.

A permutation of a string is another string composed of the same set of characters, possibly arranged in a different order. It can basically be considered as a reordering of the string letters. For instance, abcd and badc are the permutations of the same string.

Sample Examples

Example 1 : str : “Permutation”

arr : {“repuio”,”mat”, “mtatn”,”mutate”}

Output :Yes

The input string “Permutation” can be formed from the pair strings at index 0 and 2, that is “repuio” and “mtatn” which can be rearranged to form the equivalent string.

This problem can be solved by using the following two methods in C++ −

• Using sorting

• Using counting sort

Method 1: Using sorting

An input array of strings is provided. During each nested iteration of the string using for loops, a pair of strings is captured from the input array. The sorted version of the input string as well as the generated pair string is compared if its permutations evaluate to the same string.

Syntax

sort()

The sort() method in C++ is used to sort the given string ascending or descending orderely.

sort(str.begin() , str.end())

Parameters

str.begin() - The starting of the string.

str.end() - The end of the string.

Algorithm

• Step 1 − An input string and an array of strings is accepted.

• Step 2 − The string is initially sorted using the sort() method in C++.

• Step 3 − A nested loop iteration of the string is performed, wherein pairs of strings are accessed at a single time, using the pointers i and j. Each time a loop for j begins at the index i and goes on until the length of the string. Both the strings at indices i and j are accessed together and concatenated.

• Step 4 − The concatenated string is then sorted again using the sort() method.

• Step 5 − The concatenated string and the input sorted string are then compared. If they are equivalent, true is returned. Else, if none of the pair matches, false is returned.

Example

The following C++ code snippet is used to take as input a sample string and an array of strings and find out if the sample string can be generated using any pair of strings from the array −

//including the required libraries
#include <bits/stdc++.h>
using namespace std;

//check if string can be formed by permutations of two strings
bool permutation( string str,vector<string> arr) {
   int size = arr.size();

   //sorting the given string
   sort(str.begin(), str.end());

   //extracting two strings at a time
   for (int i = 0; i < size - 1; i++) {
      for (int j = i + 1; j < size; j++) {

         //concatenate the pair of string
         string concat = arr[i] + arr[j];

         // Sort the resultant string
         sort(concat.begin(), concat.end());

         //comparing if the order of characters in both strings are same
         if (concat.compare(str) == 0) {

            //if equal
            return true;
         }
      }
   }

   //no such combination exists
   return false;
}
int main(){

   //declaring the input string
   string str = "tutorials";

   //array of strings
   vector<string> arr{ "trils", "outa", "ginc", "abc" };
   bool res = permutation(str,arr);
   if(res)
      cout << "Yes, the string can be formed by permutation of two other strings";
   else
      cout << "No, the string can't be formed by permutation of two other strings";
   return 0;
}

Output

Yes, the string can be formed by permutation of two other strings

Method 2: Using counting sort

An input array of strings and a sample string is provided. The sample string is sorted using count sort. During each nested iteration of the string using for loops, a pair of strings is captured from the input array. The concatenated string, then generated, is also sorted using counting sort. The string as well as the generated pair string is compared if its permutations evaluate to the same string.

Counting Sort

An array of size 26 characters can be maintained to store the frequency of occurrence of each character in the string. This is eventually followed by extracting the characters in increasing order in order to obtain a sorted string.

Algorithm

• Step 1 − An input string and an array of strings is accepted.

• Step 2 − The string is initially sorted using the counting sort algorithm.

• Step 3 − A nested loop iteration of the string is performed, wherein pairs of strings are accessed at a single time, using the pointers i and j.

• Step 4 − Each time a loop for j begins at the index i and goes on until the length of the string. Both the strings at indices i and j are accessed together and concatenated.

• Step 5 − The concatenated string is then sorted again using the counting sort mechanism.

• Step 6 − The concatenated string and the input sorted string are then compared. If they are equivalent, true is returned. Else, if none of the pair matches, false is returned.

Example

//including the required libraries
#include <bits/stdc++.h>
using namespace std;

// Function to sort the given string
// using counting sort
void countsort(string& str){

   //declaring the numbr of characters
   int numchar = 26;

   //string length
   int len = str.length();

   //initialise the count of array
   int count[numchar] = { 0 };

   //declaring an index param
   int idx = 0;

   //traversing the string
   for (int i = 0; i < len; i++) {
      char ch = str[i] ;
      count[ch - 'a']++;
   }

   //increasing order insertion
   for (int i = 0; i < numchar; i++) {
      int j = 0;
      for (j=0; j < count[i];j++) {
         str[idx] = i + 'a';
         idx++;
      }
   }
}

//check if string can be formed by permutations of two strings
bool permutation( string str,vector<string> arr){
   int size = arr.size();

   //sorting the given string
   countsort(str);

   //extracting two strings at a time
   for (int i = 0; i < size - 1; i++) {
      for (int j = i + 1; j < size; j++) {

         //concatenate the pair of string
         string concat = arr[i] + arr[j];

         // Sort the resultant string
         countsort(concat);

         //comparing if the order of characters in both strings are same
         if (concat.compare(str) == 0) {

            //if equal
            return true;
         }
      }
   }

   //no such combination exists
   return false;
}
int main(){

   //declaring the input string
   string str = "tutorials";

   //array of strings
   vector<string> arr{ "trils", "outa", "ginc", "abc" };
   printf("\nString 2:\n");
   for (int i = 0; i <4 ; i++){
      cout<<arr[i]<<endl;
   }
   bool res = permutation(str,arr);
   if(res)
      cout << "Yes, the string can be formed by permutation of two other strings";
   else
      cout << "No, the string can't be formed by permutation of two other strings";
   return 0;
}

Output

String 2:
trils
outa
ginc
abc
Yes, the string can be formed by permutation of two other strings

Conclusion

Since, the counting sort mechanism takes into role only the evaluation of the character array of a finite size, that is 26, the second approach is considered to be better than the first one. The second approach reduces the time complexity of a polynomial time approach to a nearly polynomial approximation.