# Find Binary String of size at most 3N containing at least 2 given strings of size 2N as subsequences

Given three binary strings a, b, and c each having 2*N characters each, the task is to find a string having almost 3*N characters such that at least two of the given three strings occur as its one of the subsequence.

Examples:

Input: a = “00”, b = “11”, c = “01”
Output: “010”
Explanation: The strings “00” and “01” are subsequences of string “010” and is has not more than 3*N characters. Also, “001”, “011” can be the possible answers.

Input: a = “011001”, b = “111010”, c = “010001”
Output: “011001010″
Explanation: Here, all the three given strings occur as the subsequences of the output string.

Approach: The given problem can be solved using the following observations:

• It can be observed that according to the Pigeonhole Principle, there must exist a set of two strings such that the most frequent character in both the strings is the same and its frequency is >=N.
• Hence, for two such strings, a string of N most frequent characters can be created. The other remaining N characters of both the strings can be appended into the string respectively according to the order they occur. Therefore, the maximum size of the resultant string will be at most 3*N.

Therefore, after finding the set of strings with the same most frequent element, the rest can be solved using the two-pointer approach. Maintain two pointers, one for each string, and follow the below steps:

• Initially, i =0 and j = 0, where i represent the 1st string s1 and j represent the second string s2.
• If s1[i] is not equal to the most frequent character, print s1[i] and increment i.
• If s2[j] is not equal to the most frequent character, print s2[i] and increment j.
• If both s1[i] and s2[j] is representing the most frequent character, print s1[i] and increment both i and j.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to find most frequent` `// character in the given string` `char` `MostFrequent(string s)` `{` `    ``// Stores the frequency of` `    ``// 0 and 1 respectively` `    ``int` `arr[] = { 0, 0 };`   `    ``for` `(``char` `ch : s) {` `        ``arr[ch - ``'0'``]++;` `    ``}`   `    ``// Stores most frequent character` `    ``char` `result = arr[0] > arr[1] ? ``'0'` `: ``'1'``;`   `    ``// Return Answer` `    ``return` `result;` `}`   `// Function to find a Binary String of` `// at most 3N characters having at least` `// two of the given three strings of 2N` `// characters as one of its subsequence` `void` `findStr(string& a, string& b, string& c)` `{` `    ``// Stores most frequent char` `    ``char` `freq;`   `    ``// Stores the respective string` `    ``// with most frequent values` `    ``string s1, s2;`   `    ``// Code to find the set of` `    ``// two strings with same` `    ``// most frequent characters` `    ``if` `(MostFrequent(a) == MostFrequent(b)) {` `        ``s1 = a;` `        ``s2 = b;` `        ``freq = MostFrequent(a);` `    ``}` `    ``else` `if` `(MostFrequent(a) == MostFrequent(c)) {` `        ``s1 = a;` `        ``s2 = c;` `        ``freq = MostFrequent(a);` `    ``}` `    ``else` `{` `        ``s1 = b;` `        ``s2 = c;` `        ``freq = MostFrequent(b);` `    ``}`   `    ``// Pointer to iterate strings` `    ``int` `i = 0, j = 0;`   `    ``// Traversal using the` `    ``// two-pointer approach` `    ``while` `(i < s1.size() && j < s2.size()) {`   `        ``// if current character` `        ``// is not most frequent` `        ``while` `(i < s1.size() && s1[i] != freq) {` `            ``cout << s1[i++];` `        ``}` `        ``// if current character` `        ``// is not most frequent` `        ``while` `(j < s2.size() && s2[j] != freq) {` `            ``cout << s2[j++];` `        ``}`   `        ``// If end of string is reached` `        ``if` `(i == s1.size() || j == s2.size())` `            ``break``;`   `        ``// If both string character` `        ``// are same as most frequent` `        ``if` `(s1[i] == s2[j]) {` `            ``cout << s1[i];` `            ``i++;` `            ``j++;` `        ``}` `        ``else` `{` `            ``cout << s1[i];` `            ``i++;` `        ``}` `    ``}`   `    ``// Print leftover characters` `    ``// of the string s1` `    ``while` `(i < s1.size()) {` `        ``cout << s1[i++];` `    ``}`   `    ``// Print leftover characters` `    ``// of the string s2` `    ``while` `(j < s2.size()) {` `        ``cout << s2[j++];` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``string a, b, c;` `    ``a = ``"00"``;` `    ``b = ``"11"``;` `    ``c = ``"01"``;`   `    ``findStr(a, b, c);` `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `class` `GFG` `{` `  ``// Function to find most frequent` `  ``// character in the given String` `  ``static` `char` `MostFrequent(String s)` `  ``{` `    ``// Stores the frequency of` `    ``// 0 and 1 respectively` `    ``int` `[]arr = { ``0``, ``0` `};`   `    ``for``(``char` `ch : s.toCharArray()) {` `      ``arr[ch - ``'0'``]++;` `    ``}`   `    ``// Stores most frequent character` `    ``char` `result = arr[``0``] > arr[``1``] ? ``'0'` `: ``'1'``;`   `    ``// Return Answer` `    ``return` `result;` `  ``}`   `  ``// Function to find a Binary String of` `  ``// at most 3N characters having at least` `  ``// two of the given three Strings of 2N` `  ``// characters as one of its subsequence` `  ``static` `void` `findStr(String a, String b, String c)` `  ``{` `    ``// Stores most frequent char` `    ``char` `freq;`   `    ``// Stores the respective String` `    ``// with most frequent values` `    ``String s1 = ``""``, s2 = ``""``;`   `    ``// Code to find the set of` `    ``// two Strings with same` `    ``// most frequent characters` `    ``if` `(MostFrequent(a) == MostFrequent(b)) {` `      ``s1 = a;` `      ``s2 = b;` `      ``freq = MostFrequent(a);` `    ``}` `    ``else` `if` `(MostFrequent(a) == MostFrequent(c)) {` `      ``s1 = a;` `      ``s2 = c;` `      ``freq = MostFrequent(a);` `    ``}` `    ``else` `{` `      ``s1 = b;` `      ``s2 = c;` `      ``freq = MostFrequent(b);` `    ``}`   `    ``// Pointer to iterate Strings` `    ``int` `i = ``0``, j = ``0``;`   `    ``// Traversal using the` `    ``// two-pointer approach` `    ``while` `(i < s1.length()&& j < s2.length()) {`   `      ``// if current character` `      ``// is not most frequent` `      ``while` `(i < s1.length() && s1.charAt(i) != freq) {` `        ``System.out.print(s1.charAt(i++));` `      ``}` `      ``// if current character` `      ``// is not most frequent` `      ``while` `(j < s2.length() && s2.charAt(j) != freq) {` `        ``System.out.print(s2.charAt(j++));` `      ``}`   `      ``// If end of String is reached` `      ``if` `(i == s1.length()|| j == s2.length())` `        ``break``;`   `      ``// If both String character` `      ``// are same as most frequent` `      ``if` `(s1.charAt(i) == s2.charAt(j)) {` `        ``System.out.print(s1.charAt(i));` `        ``i++;` `        ``j++;` `      ``}` `      ``else` `{` `        ``System.out.print(s1.charAt(i));` `        ``i++;` `      ``}` `    ``}`   `    ``// Print leftover characters` `    ``// of the String s1` `    ``while` `(i < s1.length()) {` `      ``System.out.print(s1.charAt(i++));` `    ``}`   `    ``// Print leftover characters` `    ``// of the String s2` `    ``while` `(j < s2.length()) {` `      ``System.out.print(s2.charAt(j++));` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String args[])` `  ``{` `    ``String a = ``"00"``;` `    ``String b = ``"11"``;` `    ``String c = ``"01"``;`   `    ``findStr(a, b, c);` `  ``}` `}`   `// This code is contributed Saurabh Jaiswal`

## C#

 `// C# program for the above approach` `using` `System;` `class` `GFG` `{` `  ``// Function to find most frequent` `  ``// character in the given string` `  ``static` `char` `MostFrequent(``string` `s)` `  ``{` `    ``// Stores the frequency of` `    ``// 0 and 1 respectively` `    ``int` `[]arr = { 0, 0 };`   `    ``foreach` `(``char` `ch ``in` `s) {` `      ``arr[ch - ``'0'``]++;` `    ``}`   `    ``// Stores most frequent character` `    ``char` `result = arr[0] > arr[1] ? ``'0'` `: ``'1'``;`   `    ``// Return Answer` `    ``return` `result;` `  ``}`   `  ``// Function to find a Binary String of` `  ``// at most 3N characters having at least` `  ``// two of the given three strings of 2N` `  ``// characters as one of its subsequence` `  ``static` `void` `findStr(``string` `a, ``string` `b, ``string` `c)` `  ``{` `    ``// Stores most frequent char` `    ``char` `freq;`   `    ``// Stores the respective string` `    ``// with most frequent values` `    ``string` `s1 = ``""``, s2 = ``""``;`   `    ``// Code to find the set of` `    ``// two strings with same` `    ``// most frequent characters` `    ``if` `(MostFrequent(a) == MostFrequent(b)) {` `      ``s1 = a;` `      ``s2 = b;` `      ``freq = MostFrequent(a);` `    ``}` `    ``else` `if` `(MostFrequent(a) == MostFrequent(c)) {` `      ``s1 = a;` `      ``s2 = c;` `      ``freq = MostFrequent(a);` `    ``}` `    ``else` `{` `      ``s1 = b;` `      ``s2 = c;` `      ``freq = MostFrequent(b);` `    ``}`   `    ``// Pointer to iterate strings` `    ``int` `i = 0, j = 0;`   `    ``// Traversal using the` `    ``// two-pointer approach` `    ``while` `(i < s1.Length && j < s2.Length) {`   `      ``// if current character` `      ``// is not most frequent` `      ``while` `(i < s1.Length && s1[i] != freq) {` `        ``Console.Write(s1[i++]);` `      ``}` `      ``// if current character` `      ``// is not most frequent` `      ``while` `(j < s2.Length && s2[j] != freq) {` `        ``Console.Write(s2[j++]);` `      ``}`   `      ``// If end of string is reached` `      ``if` `(i == s1.Length || j == s2.Length)` `        ``break``;`   `      ``// If both string character` `      ``// are same as most frequent` `      ``if` `(s1[i] == s2[j]) {` `        ``Console.Write(s1[i]);` `        ``i++;` `        ``j++;` `      ``}` `      ``else` `{` `        ``Console.Write(s1[i]);` `        ``i++;` `      ``}` `    ``}`   `    ``// Print leftover characters` `    ``// of the string s1` `    ``while` `(i < s1.Length) {` `      ``Console.Write(s1[i++]);` `    ``}`   `    ``// Print leftover characters` `    ``// of the string s2` `    ``while` `(j < s2.Length) {` `      ``Console.Write(s2[j++]);` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main()` `  ``{` `    ``string` `a = ``"00"``;` `    ``string` `b = ``"11"``;` `    ``string` `c = ``"01"``;`   `    ``findStr(a, b, c);` `  ``}` `}`   `// This code is contributed Samim Hossain Mondal.`

## Python3

 `# python3 program for the above approach`   `# Function to find most frequent` `# character in the given string` `def` `MostFrequent(s):`   `    ``# Stores the frequency of` `    ``# 0 and 1 respectively` `    ``arr ``=` `[``0``, ``0``]`   `    ``for` `ch ``in` `s:` `        ``arr[``ord``(ch) ``-` `ord``(``'0'``)] ``+``=` `1`   `    ``# Stores most frequent character` `    ``result ``=` `'0'` `if` `arr[``0``] > arr[``1``] ``else` `'1'`   `    ``# Return Answer` `    ``return` `result`   `# Function to find a Binary String of` `# at most 3N characters having at least` `# two of the given three strings of 2N` `# characters as one of its subsequence` `def` `findStr(a, b, c):`   `    ``# Stores most frequent char` `    ``freq ``=` `''`   `    ``# Stores the respective string` `    ``# with most frequent values` `    ``s1, s2 ``=` `"``", "``"`   `    ``# Code to find the set of` `    ``# two strings with same` `    ``# most frequent characters` `    ``if` `(MostFrequent(a) ``=``=` `MostFrequent(b)):` `        ``s1 ``=` `a` `        ``s2 ``=` `b` `        ``freq ``=` `MostFrequent(a)`   `    ``elif` `(MostFrequent(a) ``=``=` `MostFrequent(c)):` `        ``s1 ``=` `a` `        ``s2 ``=` `c` `        ``freq ``=` `MostFrequent(a)`   `    ``else``:` `        ``s1 ``=` `b` `        ``s2 ``=` `c` `        ``freq ``=` `MostFrequent(b)`   `    ``# Pointer to iterate strings` `    ``i, j ``=` `0``, ``0`   `    ``# Traversal using the` `    ``# two-pointer approach` `    ``while` `(i < ``len``(s1) ``and` `j < ``len``(s2)):`   `        ``# if current character` `        ``# is not most frequent` `        ``while` `(i < ``len``(s1) ``and` `s1[i] !``=` `freq):` `            ``print``(s1[i], end``=``"")` `            ``i ``+``=` `1`   `        ``# if current character` `        ``# is not most frequent` `        ``while` `(j < ``len``(s2) ``and` `s2[j] !``=` `freq):` `            ``print``(s2[j], end``=``"")` `            ``j ``+``=` `1`   `        ``# If end of string is reached` `        ``if` `(i ``=``=` `len``(s1) ``or` `j ``=``=` `len``(s2)):` `            ``break`   `        ``# If both string character` `        ``# are same as most frequent` `        ``if` `(s1[i] ``=``=` `s2[j]):` `            ``print``(s1[i], end``=``"")` `            ``i ``+``=` `1` `            ``j ``+``=` `1`   `        ``else``:` `            ``print``(s1[i], end``=``"")` `            ``i ``+``=` `1`   `    ``# Print leftover characters` `    ``# of the string s1` `    ``while` `(i < ``len``(s1)):` `        ``print``(s1[i], end``=``"")` `        ``i ``+``=` `1`   `    ``# Print leftover characters` `    ``# of the string s2` `    ``while` `(j < ``len``(s2)):` `        ``print``(s2[j], end``=``"")` `        ``j ``+``=` `1`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``a ``=` `"00"` `    ``b ``=` `"11"` `    ``c ``=` `"01"`   `    ``findStr(a, b, c)`   `    ``# This code is contributed by rakeshsahni`

## Javascript

 ``

Output

`011`

Time Complexity: O(N)
Auxiliary Space: O(N)

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