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

Given a string str and an array of strings arr[], the task is to check if the given string can be formed by any of the string pair from the array or their permutations.

Examples:

Input: str = “amazon”, arr[] = {“loa”, “azo”, “ft”, “amn”, “lka”}
Output: Yes
The chosen strings are “amn” and “azo”
which can be rearranged as “amazon”.

Input: str = “geeksforgeeks”, arr[] = {“geeks”, “geek”, “for”}
Output: No

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Method 1: We sort the given string first then run two nested loops and select two strings from the given array at a time and concatenate them and then sort the resultant string.
After sorting we check if it is equal to our given sorted string.
Hence, overall time complexity will be O(n * mlogm) where n is the size of the given array and m is the length of the strings (maximum).

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function that returns true if str can be ` `// generated from any permutation of the ` `// two strings selected from the given vector ` `bool` `isPossible(vector v, string str) ` `{ ` ` `  `    ``// Sort the given string ` `    ``sort(str.begin(), str.end()); ` ` `  `    ``// Select two strings at a time from given vector ` `    ``for` `(``int` `i = 0; i < v.size() - 1; i++) { ` `        ``for` `(``int` `j = i + 1; j < v.size(); j++) { ` ` `  `            ``// Get the concatenated string ` `            ``string temp = v[i] + v[j]; ` ` `  `            ``// Sort the resultant string ` `            ``sort(temp.begin(), temp.end()); ` ` `  `            ``// If the resultant string is equal ` `            ``// to the given string str ` `            ``if` `(temp.compare(str) == 0) { ` `                ``return` `true``; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// No valid pair found ` `    ``return` `false``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``string str = ``"amazon"``; ` `    ``vector v{ ``"fds"``, ``"oxq"``, ``"zoa"``, ``"epw"``, ``"amn"` `}; ` ` `  `    ``if` `(isPossible(v, str)) ` `        ``cout << ``"Yes"``; ` `    ``else` `        ``cout << ``"No"``; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` ` `  `// Function that returns true if str can be ` `// generated from any permutation of the ` `// two strings selected from the given vector ` `static` `boolean` `isPossible(Vector v, String str) ` `{ ` ` `  `    ``// Sort the given string ` `    ``str = sortString(str); ` ` `  `    ``// Select two strings at a time from given vector ` `    ``for` `(``int` `i = ``0``; i < v.size() - ``1``; i++)  ` `    ``{ ` `        ``for` `(``int` `j = i + ``1``; j < v.size(); j++) ` `        ``{ ` ` `  `            ``// Get the concatenated string ` `            ``String temp = v.get(i) + v.get(j); ` ` `  `            ``// Sort the resultant string ` `            ``temp = sortString(temp); ` ` `  `            ``// If the resultant string is equal ` `            ``// to the given string str ` `            ``if` `(temp.compareTo(str) == ``0``)  ` `            ``{ ` `                ``return` `true``; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// No valid pair found ` `    ``return` `false``; ` `} ` ` `  `// Method to sort a string alphabetically  ` `public` `static` `String sortString(String inputString)  ` `{  ` `    ``// convert input string to char array  ` `    ``char` `tempArray[] = inputString.toCharArray();  ` `     `  `    ``// sort tempArray  ` `    ``Arrays.sort(tempArray);  ` `     `  `    ``// return new sorted string  ` `    ``return` `new` `String(tempArray);  ` `}  ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args)  ` `{ ` `    ``String str = ``"amazon"``; ` `    ``String []arr = { ``"fds"``, ``"oxq"``, ``"zoa"``, ``"epw"``, ``"amn"` `}; ` `    ``Vector v = ``new` `Vector(Arrays.asList(arr)); ` ` `  `    ``if` `(isPossible(v, str)) ` `        ``System.out.println(``"Yes"``); ` `    ``else` `        ``System.out.println(``"No"``); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## Python3

 `# Python3 implementation of the approach  ` ` `  `# Function that returns true if str can be  ` `# generated from any permutation of the  ` `# two strings selected from the given vector  ` `def` `isPossible(v, string ) :  ` `     `  `    ``char_list ``=` `list``(string) ` `     `  `    ``# Sort the given string ` `    ``char_list.sort() ` `     `  `    ``# Select two strings at a time from given vector ` `    ``for` `i ``in` `range``(``len``(v)``-``1``) : ` `        ``for` `j ``in` `range``(``len``(v)) : ` `             `  `            ``# Get the concatenated string ` `            ``temp ``=` `v[i] ``+` `v[j]; ` `             `  `            ``# Sort the resultant string  ` `            ``temp_list ``=` `list``(temp) ` `            ``temp_list.sort() ` `             `  `            ``# If the resultant string is equal ` `            ``# to the given string str ` `            ``if` `(temp_list ``=``=` `char_list) : ` `                ``return` `True``; ` `                 `  `    ``# No valid pair found ` `    ``return` `False``;  ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `:  ` ` `  `    ``string ``=` `"amazon"``;  ` `    ``v ``=` `[ ``"fds"``, ``"oxq"``, ``"zoa"``, ``"epw"``, ``"amn"` `];  ` ` `  `    ``if` `(isPossible(v, string)): ` `        ``print``(``"Yes"``);  ` `    ``else` `: ` `        ``print``(``"No"``);  ` `         `  `# This code is contributed by AnkitRai01 `

## C#

 `// C# implementation of the approach ` `using` `System; ` `using` `System.Collections.Generic;  ` ` `  `class` `GFG  ` `{ ` ` `  `// Function that returns true if str can be ` `// generated from any permutation of the ` `// two strings selected from the given vector ` `static` `Boolean isPossible(List v, String str) ` `{ ` ` `  `    ``// Sort the given string ` `    ``str = sortString(str); ` ` `  `    ``// Select two strings at a time from given vector ` `    ``for` `(``int` `i = 0; i v = ``new` `List(arr); ` ` `  `    ``if` `(isPossible(v, str)) ` `        ``Console.WriteLine(``"Yes"``); ` `    ``else` `        ``Console.WriteLine(``"No"``); ` `} ` `} ` ` `  `// This code is contributed by Princi Singh `

Output:

```Yes
```

Method 2: Counting sort can be used to reduce the running time of the above approach. Counting sort uses a table to store the count of each character. We have 26 alphabets hence we make an array of size 26 to store counts of each character in the string. Then take the characters in increasing order to get the sorted string.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` `#define MAX 26 ` ` `  `// Function to sort the given string ` `// using counting sort ` `void` `countingsort(string& s) ` `{ ` `    ``// Array to store the count of each character ` `    ``int` `count[MAX] = { 0 }; ` `    ``for` `(``int` `i = 0; i < s.length(); i++) { ` `        ``count[s[i] - ``'a'``]++; ` `    ``} ` `    ``int` `index = 0; ` ` `  `    ``// Insert characters in the string ` `    ``// in increasing order ` `    ``for` `(``int` `i = 0; i < MAX; i++) { ` `        ``int` `j = 0; ` `        ``while` `(j < count[i]) { ` `            ``s[index++] = i + ``'a'``; ` `            ``j++; ` `        ``} ` `    ``} ` `} ` ` `  `// Function that returns true if str can be ` `// generated from any permutation of the ` `// two strings selected from the given vector ` `bool` `isPossible(vector v, string str) ` `{ ` ` `  `    ``// Sort the given string ` `    ``countingsort(str); ` ` `  `    ``// Select two strings at a time from given vector ` `    ``for` `(``int` `i = 0; i < v.size() - 1; i++) { ` `        ``for` `(``int` `j = i + 1; j < v.size(); j++) { ` ` `  `            ``// Get the concatenated string ` `            ``string temp = v[i] + v[j]; ` ` `  `            ``// Sort the resultant string ` `            ``countingsort(temp); ` ` `  `            ``// If the resultant string is equal ` `            ``// to the given string str ` `            ``if` `(temp.compare(str) == 0) { ` `                ``return` `true``; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// No valid pair found ` `    ``return` `false``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``string str = ``"amazon"``; ` `    ``vector v{ ``"fds"``, ``"oxq"``, ``"zoa"``, ``"epw"``, ``"amn"` `}; ` ` `  `    ``if` `(isPossible(v, str)) ` `        ``cout << ``"Yes"``; ` `    ``else` `        ``cout << ``"No"``; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach  ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` `static` `int` `MAX = ``26``;  ` ` `  `// Function to sort the given string  ` `// using counting sort  ` `static` `String countingsort(``char``[] s)  ` `{  ` `     `  `    ``// Array to store the count of each character  ` `    ``int` `[]count = ``new` `int``[MAX];  ` `    ``for` `(``int` `i = ``0``; i < s.length; i++)  ` `    ``{  ` `        ``count[s[i] - ``'a'``]++;  ` `    ``}  ` `    ``int` `index = ``0``;  ` ` `  `    ``// Insert characters in the string  ` `    ``// in increasing order  ` `    ``for` `(``int` `i = ``0``; i < MAX; i++) ` `    ``{  ` `        ``int` `j = ``0``;  ` `        ``while` `(j < count[i])  ` `        ``{  ` `            ``s[index++] = (``char``)(i + ``'a'``);  ` `            ``j++;  ` `        ``}  ` `    ``}  ` `        ``return` `String.valueOf(s); ` `}  ` ` `  `// Function that returns true if str can be  ` `// generated from any permutation of the  ` `// two strings selected from the given vector  ` `static` `boolean` `isPossible(Vector v,  ` `                                 ``String str)  ` `{  ` ` `  `    ``// Sort the given string  ` `    ``str=countingsort(str.toCharArray());  ` ` `  `    ``// Select two strings at a time from given vector  ` `    ``for` `(``int` `i = ``0``; i < v.size() - ``1``; i++)  ` `    ``{  ` `        ``for` `(``int` `j = i + ``1``; j < v.size(); j++)  ` `        ``{  ` ` `  `            ``// Get the concatenated string  ` `            ``String temp = v.get(i) + v.get(j);  ` ` `  `            ``// Sort the resultant string  ` `            ``temp = countingsort(temp.toCharArray());  ` ` `  `            ``// If the resultant string is equal  ` `            ``// to the given string str  ` `            ``if` `(temp.equals(str))  ` `            ``{  ` `                ``return` `true``;  ` `            ``}  ` `        ``}  ` `    ``}  ` ` `  `    ``// No valid pair found  ` `    ``return` `false``;  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `main(String[] args)  ` `{ ` `    ``String str = ``"amazon"``;  ` `    ``String []arr = { ``"fds"``, ``"oxq"``, ``"zoa"``, ``"epw"``, ``"amn"` `}; ` `    ``Vector v = ``new` `Vector(Arrays.asList(arr)); ` ` `  `    ``if` `(isPossible(v, str))  ` `        ``System.out.println(``"Yes"``); ` `    ``else` `        ``System.out.println(``"No"``); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

## Python3

 `# Python 3 implementation of the approach ` `MAX` `=` `26` ` `  `# Function to sort the given string ` `# using counting sort ` `def` `countingsort(s): ` `    ``# Array to store the count of each character ` `    ``count ``=` `[``0` `for` `i ``in` `range``(``MAX``)] ` `    ``for` `i ``in` `range``(``len``(s)): ` `        ``count[``ord``(s[i]) ``-` `ord``(``'a'``)] ``+``=` `1` `    ``index ``=` `0` ` `  `    ``# Insert characters in the string ` `    ``# in increasing order ` `     `  `    ``for` `i ``in` `range``(``MAX``): ` `        ``j ``=` `0` `        ``while` `(j < count[i]): ` `            ``s ``=` `s.replace(s[index],``chr``(``97``+``i)) ` `            ``index ``+``=` `1` `            ``j ``+``=` `1` `         `  ` `  `# Function that returns true if str can be ` `# generated from any permutation of the ` `# two strings selected from the given vector ` `def` `isPossible(v, str1): ` `    ``# Sort the given string ` `    ``countingsort(str1); ` ` `  `    ``# Select two strings at a time from given vector ` `    ``for` `i ``in` `range``(``len``(v)``-``1``): ` `        ``for` `j ``in` `range``(i ``+` `1``,``len``(v),``1``): ` `            ``# Get the concatenated string ` `            ``temp ``=` `v[i] ``+` `v[j] ` ` `  `            ``# Sort the resultant string ` `            ``countingsort(temp) ` ` `  `            ``# If the resultant string is equal ` `            ``# to the given string str ` `            ``if` `(temp ``=``=` `str1): ` `                ``return` `False` `             `  `    ``# No valid pair found ` `    ``return` `True` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``str1 ``=` `"amazon"` `    ``v ``=` `[``"fds"``, ``"oxq"``, ``"zoa"``, ``"epw"``, ``"amn"``] ` ` `  `    ``if` `(isPossible(v, str1)): ` `        ``print``(``"Yes"``) ` `    ``else``: ` `        ``print``(``"No"``) ` ` `  `# This code is contributed by ` `# Surendra_Gangwar `

## C#

 `// C# implementation of the above approach  ` `using` `System; ` `using` `System.Collections.Generic; ` `     `  `class` `GFG  ` `{ ` `static` `int` `MAX = 26;  ` ` `  `// Function to sort the given string  ` `// using counting sort  ` `static` `String countingsort(``char``[] s)  ` `{  ` `     `  `    ``// Array to store the count of each character  ` `    ``int` `[]count = ``new` `int``[MAX];  ` `    ``for` `(``int` `i = 0; i < s.Length; i++)  ` `    ``{  ` `        ``count[s[i] - ``'a'``]++;  ` `    ``}  ` `     `  `    ``int` `index = 0;  ` ` `  `    ``// Insert characters in the string  ` `    ``// in increasing order  ` `    ``for` `(``int` `i = 0; i < MAX; i++) ` `    ``{  ` `        ``int` `j = 0;  ` `        ``while` `(j < count[i])  ` `        ``{  ` `            ``s[index++] = (``char``)(i + ``'a'``);  ` `            ``j++;  ` `        ``}  ` `    ``}  ` `        ``return` `String.Join(``""``, s); ` `}  ` ` `  `// Function that returns true if str can be  ` `// generated from any permutation of the  ` `// two strings selected from the given vector  ` `static` `Boolean isPossible(List v,  ` `                               ``String str)  ` `{  ` ` `  `    ``// Sort the given string  ` `    ``str = countingsort(str.ToCharArray());  ` ` `  `    ``// Select two strings at a time from given vector  ` `    ``for` `(``int` `i = 0; i < v.Count - 1; i++)  ` `    ``{  ` `        ``for` `(``int` `j = i + 1; j < v.Count; j++)  ` `        ``{  ` ` `  `            ``// Get the concatenated string  ` `            ``String temp = v[i] + v[j];  ` ` `  `            ``// Sort the resultant string  ` `            ``temp = countingsort(temp.ToCharArray());  ` ` `  `            ``// If the resultant string is equal  ` `            ``// to the given string str  ` `            ``if` `(temp.Equals(str))  ` `            ``{  ` `                ``return` `true``;  ` `            ``}  ` `        ``}  ` `    ``}  ` ` `  `    ``// No valid pair found  ` `    ``return` `false``;  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `Main(String[] args)  ` `{ ` `    ``String str = ``"amazon"``;  ` `    ``String []arr = { ``"fds"``, ``"oxq"``,  ` `                     ``"zoa"``, ``"epw"``, ``"amn"` `}; ` `    ``List v = ``new` `List(arr); ` ` `  `    ``if` `(isPossible(v, str))  ` `        ``Console.WriteLine(``"Yes"``); ` `    ``else` `        ``Console.WriteLine(``"No"``); ` `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992  `

Output:

```Yes
```

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.