# Check whether given string can be generated after concatenating given strings

Given three strings str, A and B. The task is to check whether str = A + B or str = B + A where + denotes concatenation.
Examples:

Input: str = “GeeksforGeeks”, A = “Geeksfo”, B = “rGeeks”
Output: Yes
str = A + B = “Geeksfo” + “rGeeks” = “GeeksforGeeks”
Input: str = “Delhicapitals”, B = “Delmi”, C = “capitals”
Output: No

Approach:

1. If len(str) != len(A) + len(B) then it is not possible to generate str by concatenating a + b or b + a.
2. Else check whether str starts with a and ends with b or it starts with b and ends with a. Print Yes if any of these is true else print No

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach` `#include ` `using` `namespace` `std;`   `// Function that return true` `// if pre is a prefix of str` `bool` `startsWith(string str, string pre)` `{` `    ``int` `strLen = str.length();` `    ``int` `preLen = pre.length();` `    ``int` `i = 0, j = 0;`   `    ``// While there are characters to match` `    ``while` `(i < strLen && j < preLen) {`   `        ``// If characters differ at any position` `        ``if` `(str[i] != pre[j])` `            ``return` `false``;` `        ``i++;` `        ``j++;` `    ``}`   `    ``// str starts with pre` `    ``return` `true``;` `}`   `// Function that return true` `// if suff is a suffix of str` `bool` `endsWith(string str, string suff)` `{` `    ``int` `i = str.length() - 0;` `    ``int` `j = suff.length() - 0;`   `    ``// While there are characters to match` `    ``while` `(i >= 0 && j >= 0) {`   `        ``// If characters differ at any position` `        ``if` `(str[i] != suff[j])` `            ``return` `false``;` `        ``i--;` `        ``j--;` `    ``}`   `    ``// str ends with suff` `    ``return` `true``;` `}`   `// Function that returns true` `// if str = a + b or str = b + a` `bool` `checkString(string str, string a, string b)` `{`   `    ``// str cannot be generated` `    ``// by concatenating a and b` `    ``if` `(str.length() != a.length() + b.length())` `        ``return` `false``;`   `    ``// If str starts with a` `    ``// i.e. a is a prefix of str` `    ``if` `(startsWith(str, a)) {`   `        ``// Check if the rest of the characters` `        ``// are equal to b i.e. b is a suffix of str` `        ``if` `(endsWith(str, b))` `            ``return` `true``;` `    ``}`   `    ``// If str starts with b` `    ``// i.e. b is a prefix of str` `    ``if` `(startsWith(str, b)) {`   `        ``// Check if the rest of the characters` `        ``// are equal to a i.e. a is a suffix of str` `        ``if` `(endsWith(str, a))` `            ``return` `true``;` `    ``}`   `    ``return` `false``;` `}`   `// Driver code` `int` `main()` `{` `    ``string str = ``"GeeksforGeeks"``;` `    ``string a = ``"Geeksfo"``;` `    ``string b = ``"rGeeks"``;`   `    ``if` `(checkString(str, a, b))` `        ``cout << ``"Yes"``;` `    ``else` `        ``cout << ``"No"``;`   `    ``return` `0;` `}`

## Java

 `// Java implementation of the approach` `import` `java.util.*;`   `class` `GFG` `{ ` `    `  `// Function that return true` `// if pre is a prefix of str` `static` `boolean` `startsWith(String str, String pre)` `{` `    ``int` `strLen = str.length();` `    ``int` `preLen = pre.length();` `    ``int` `i = ``0``, j = ``0``;`   `    ``// While there are characters to match` `    ``while` `(i < strLen && j < preLen) ` `    ``{`   `        ``// If characters differ at any position` `        ``if` `(str.charAt(i) != pre.charAt(j))` `            ``return` `false``;` `        ``i++;` `        ``j++;` `    ``}`   `    ``// str starts with pre` `    ``return` `true``;` `}`   `// Function that return true` `// if suff is a suffix of str` `static` `boolean` `endsWith(String str, String suff)` `{` `    ``int` `i = str.length() - ``1``;` `    ``int` `j = suff.length() - ``1``;`   `    ``// While there are characters to match` `    ``while` `(i >= ``0` `&& j >= ``0``) ` `    ``{`   `        ``// If characters differ at any position` `        ``if` `(str.charAt(i) != suff.charAt(j))` `            ``return` `false``;` `        ``i--;` `        ``j--;` `    ``}`   `    ``// str ends with suff` `    ``return` `true``;` `}`   `// Function that returns true` `// if str = a + b or str = b + a` `static` `boolean` `checkString(String str, String a, String b)` `{`   `    ``// str cannot be generated` `    ``// by concatenating a and b` `    ``if` `(str.length() != a.length() + b.length())` `        ``return` `false``;`   `    ``// If str starts with a` `    ``// i.e. a is a prefix of str` `    ``if` `(startsWith(str, a)) ` `    ``{`   `        ``// Check if the rest of the characters` `        ``// are equal to b i.e. b is a suffix of str` `        ``if` `(endsWith(str, b))` `            ``return` `true``;` `    ``}`   `    ``// If str starts with b` `    ``// i.e. b is a prefix of str` `    ``if` `(startsWith(str, b)) ` `    ``{`   `        ``// Check if the rest of the characters` `        ``// are equal to a i.e. a is a suffix of str` `        ``if` `(endsWith(str, a))` `            ``return` `true``;` `    ``}`   `    ``return` `false``;` `}`   `// Driver code` `public` `static` `void` `main(String args[])` `{` `    ``String str = ``"GeeksforGeeks"``;` `    ``String a = ``"Geeksfo"``;` `    ``String b = ``"rGeeks"``;`   `    ``if` `(checkString(str, a, b))` `        ``System.out.println(``"Yes"``);` `    ``else` `        ``System.out.println(``"No"``);`   `}` `}`   `// This code is contributed by Arnab Kundu`

## Python3

 `# Python3 implementation of the approach `   `# Function that return true ` `# if pre is a prefix of str ` `def` `startsWith(``str``, pre):` `    ``strLen ``=` `len``(``str``)` `    ``preLen ``=` `len``(pre)` `    ``i ``=` `0` `    ``j ``=` `0` `    `  `    ``# While there are characters to match ` `    ``while` `(i < strLen ``and` `j < preLen):` `        `  `        ``# If characters differ at any position ` `        ``if` `(``str``[i] !``=` `pre[j]) :` `            ``return` `False` `        ``i ``+``=` `1` `        ``j ``+``=` `1` `        `  `    ``# str starts with pre ` `    ``return` `True` `    `  `# Function that return true ` `# if suff is a suffix of str ` `def` `endsWith(``str``, suff):` `    ``i ``=` `len``(``str``) ``-` `1` `    ``j ``=` `len``(suff) ``-` `1` `    `  `    ``# While there are characters to match ` `    ``while` `(i >``=` `0` `and` `j >``=` `0``):` `        `  `        ``# If characters differ at any position ` `        ``if` `(``str``[i] !``=` `suff[j]):` `            ``return` `False` `        ``i ``-``=` `1` `        ``j ``-``=` `1` `    `  `    ``# str ends with suff ` `    ``return` `True`   `# Function that returns true ` `# if str = a + b or str = b + a ` `def` `checkString(``str``, a, b):` `    `  `    ``# str cannot be generated ` `    ``# by concatenating a and b ` `    ``if` `(``len``(``str``) !``=` `len``(a) ``+` `len``(b)):` `        ``return` `False` `        `  `    ``# If str starts with a ` `    ``# i.e. a is a prefix of str ` `    ``if` `(startsWith(``str``, a)):`   `        ``# Check if the rest of the characters ` `        ``# are equal to b i.e. b is a suffix of str ` `        ``if` `(endsWith(``str``, b)):` `            ``return` `True` `    `  `    ``# If str starts with b ` `    ``# i.e. b is a prefix of str ` `    ``if` `(startsWith(``str``, b)):` `        `  `        ``# Check if the rest of the characters ` `        ``# are equal to a i.e. a is a suffix of str ` `        ``if` `(endsWith(``str``, a)):` `            ``return` `True` `    `  `    ``return` `False` `    `  `# Driver code ` `str` `=` `"GeeksforGeeks"` `a ``=` `"Geeksfo"` `b ``=` `"rGeeks"`   `if` `(checkString(``str``, a, b)):` `    ``print``(``"Yes"``)` `else``:` `    ``print``(``"No"``)`   `# This code is contributed by SHUBHAMSINGH10`

## C#

 `// C# implementation of the approach` `using` `System;`   `class` `GFG` `{ ` `    `  `// Function that return true` `// if pre is a prefix of str` `static` `Boolean startsWith(String str, ` `                          ``String pre)` `{` `    ``int` `strLen = str.Length;` `    ``int` `preLen = pre.Length;` `    ``int` `i = 0, j = 0;`   `    ``// While there are characters to match` `    ``while` `(i < strLen && j < preLen) ` `    ``{`   `        ``// If characters differ at any position` `        ``if` `(str[i] != pre[j])` `            ``return` `false``;` `        ``i++;` `        ``j++;` `    ``}`   `    ``// str starts with pre` `    ``return` `true``;` `}`   `// Function that return true` `// if suff is a suffix of str` `static` `Boolean endsWith(String str, ` `                        ``String suff)` `{` `    ``int` `i = str.Length - 1;` `    ``int` `j = suff.Length - 1;`   `    ``// While there are characters to match` `    ``while` `(i >= 0 && j >= 0) ` `    ``{`   `        ``// If characters differ at any position` `        ``if` `(str[i] != suff[j])` `            ``return` `false``;` `        ``i--;` `        ``j--;` `    ``}`   `    ``// str ends with suff` `    ``return` `true``;` `}`   `// Function that returns true` `// if str = a + b or str = b + a` `static` `Boolean checkString(String str, ` `                           ``String a, ` `                           ``String b)` `{`   `    ``// str cannot be generated` `    ``// by concatenating a and b` `    ``if` `(str.Length != a.Length + b.Length)` `        ``return` `false``;`   `    ``// If str starts with a` `    ``// i.e. a is a prefix of str` `    ``if` `(startsWith(str, a)) ` `    ``{`   `        ``// Check if the rest of the characters` `        ``// are equal to b i.e. b is a suffix of str` `        ``if` `(endsWith(str, b))` `            ``return` `true``;` `    ``}`   `    ``// If str starts with b` `    ``// i.e. b is a prefix of str` `    ``if` `(startsWith(str, b)) ` `    ``{`   `        ``// Check if the rest of the characters` `        ``// are equal to a i.e. a is a suffix of str` `        ``if` `(endsWith(str, a))` `            ``return` `true``;` `    ``}`   `    ``return` `false``;` `}`   `// Driver code` `public` `static` `void` `Main(String []args)` `{` `    ``String str = ``"GeeksforGeeks"``;` `    ``String a = ``"Geeksfo"``;` `    ``String b = ``"rGeeks"``;`   `    ``if` `(checkString(str, a, b))` `        ``Console.WriteLine(``"Yes"``);` `    ``else` `        ``Console.WriteLine(``"No"``);` `}` `}`   `// This code is contributed by 29AjayKumar`

## PHP

 `= 0 && ``\$j` `>= 0) ` `    ``{ `   `        ``// If characters differ at any position ` `        ``if` `(``\$str``[``\$i``] != ``\$suff``[``\$j``]) ` `            ``return` `false; ` `        ``\$i``--; ` `        ``\$j``--; ` `    ``} `   `    ``// str ends with suff ` `    ``return` `true; ` `} `   `// Function that returns true ` `// if str = a + b or str = b + a ` `function` `checkString(``\$str``, ``\$a``, ``\$b``) ` `{ `   `    ``// str cannot be generated ` `    ``// by concatenating a and b ` `    ``if` `(``strlen``(``\$str``) != ``strlen``(``\$a``) + ``strlen``(``\$b``))` `        ``return` `false; `   `    ``// If str starts with a ` `    ``// i.e. a is a prefix of str ` `    ``if` `(startsWith(``\$str``, ``\$a``)) ` `    ``{ `   `        ``// Check if the rest of the characters ` `        ``// are equal to b i.e. b is a suffix of str ` `        ``if` `(endsWith(``\$str``, ``\$b``)) ` `            ``return` `true; ` `    ``} `   `    ``// If str starts with b ` `    ``// i.e. b is a prefix of str ` `    ``if` `(startsWith(``\$str``, ``\$b``)) ` `    ``{ `   `        ``// Check if the rest of the characters ` `        ``// are equal to a i.e. a is a suffix of str ` `        ``if` `(endsWith(``\$str``, ``\$a``)) ` `            ``return` `true; ` `    ``} `   `    ``return` `false; ` `} `   `// Driver code ` `\$str` `= ``"GeeksforGeeks"``; ` `\$a` `= ``"Geeksfo"``; ` `\$b` `= ``"rGeeks"``; `   `if` `(checkString(``\$str``, ``\$a``, ``\$b``)) ` `    ``echo` `"Yes"``; ` `else` `    ``echo` `"No"``; `   `// This code is contributed by AnkitRai01` `?>`

## Javascript

 ``

Output:

`Yes`

Time Complexity: O(max(a,b,c)), as we are using a loop to traverse a, b, and c times. Where a, b, and c are the length of the strings.

Auxiliary Space: O(1), as we are not using any extra space.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next