 Open in App
Not now

# Find the shortest Binary string containing one or more occurrences of given strings

• Last Updated : 15 Sep, 2021

Given two Binary strings, S1 and S2, the task is to generate a new Binary strings (of least length possible) which can be stated as one or more occurrences of S1 as well as S2. If it is not possible to generate such a string, return -1 in output. Please note that the resultant string must not have incomplete strings S1 or S2.

For example, “1111” can be the resultant string for “11” and “1111” as it is 1 occurrence of “1111” and can also be judged as two occurrences of “11”.

Examples:

Input: S1 = “1010”, S2 = “101010”
Output: 101010101010
Explanation: The resultant string is 3 occurrences of s1 and 2 occurrences of s2.

Input: S1 = “000”, S2 = “101”
Output: -1
Explanation: There is no way possible to construct such a string.

Approach: If it is possible to make such a string, then it’s length will be the LCM of lengths of strings S1 and S2. Because only then, it can be stated as a minimum multiple of string S1 and S2. Follow the steps below to solve the problem:

• Define a function repeat(int k, string S) and perform the following tasks:
• Initialize the variables x and y as the lengths of the strings S1 and S2.
• Initialize the variable gcd as the GCD of x and y.
• Call the function repeat(y/gcd, s1) to form the string S1 that many times and store that into the variable A.
• Call the function repeat(x/gcd, s2) to form the string S2 that many times and store that into the variable B.
• If A is equal to B, then print any one of them as the answer, else print “NO”.

Below is the implementation of the above approach.

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to form the resultant string``string repeat(``int` `k, string S)``{``    ``string r = ``""``;``    ``while` `(k--) {``        ``r += S;``    ``}``    ``return` `r;``}` `// Function to find if any such string``// exists or not. If yes, find it``void` `find(string s1, string s2)``{``    ``int` `x = s1.size(), y = s2.size();` `    ``// GCD of x and y``    ``int` `gcd = __gcd(x, y);` `    ``// Form the resultant strings``    ``string A = repeat(y / gcd, s1);``    ``string B = repeat(x / gcd, s2);` `    ``// If both the strings are same,``    ``// then print the answer``    ``if` `(A == B) {``        ``cout << A;``    ``}``    ``else` `{``        ``cout << ``"-1"``;``    ``}``}` `// Driver Code``int` `main()``{` `    ``// Initializing strings``    ``string s1 = ``"1010"``, s2 = ``"101010"``;` `    ``find(s1, s2);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;` `class` `GFG {``    ``public` `static` `int` `GCD(``int` `a, ``int` `b)``    ``{``        ``// Everything divides 0``        ``if` `(a == ``0``)``            ``return` `b;``        ``if` `(b == ``0``)``            ``return` `a;` `        ``// base case``        ``if` `(a == b)``            ``return` `a;` `        ``// a is greater``        ``if` `(a > b)``            ``return` `GCD(a - b, b);``        ``return` `GCD(a, b - a);``    ``}` `    ``public` `static` `String repeat(``int` `k, String S)``    ``{``        ``String r = ``""``;``        ``while` `(k--!=``0``) {``            ``r += S;``        ``}``        ``return` `r;``    ``}` `    ``// Function to find if any such string``    ``// exists or not. If yes, find it``    ``public` `static` `void` `find(String s1, String s2)``    ``{``        ``int` `x = s1.length(), y = s2.length();` `        ``// GCD of x and y``        ``int` `gcd = GCD(x, y);` `        ``// Form the resultant strings``        ``String A = repeat(y / gcd, s1);``        ``String B = repeat(x / gcd, s2);` `        ``// If both the strings are same,``        ``// then print the answer``        ``if` `(A.equals(B)) {``            ``System.out.println(A);``        ``}``        ``else` `{``            ``System.out.println(``"-1"``);``        ``}``    ``}` `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)``    ``{``      ` `        ``// Initializing strings``        ``String s1 = ``"1010"``, s2 = ``"101010"``;` `        ``find(s1, s2);``    ``}``}` `// This code is contributed by maddler.`

## Python3

 `# Python program for the above approach``import` `math` `# Function to form the resultant string``def` `repeat(k, S):``    ``r ``=` `""``    ``while` `(k):``        ``r ``+``=` `S``        ``k``-``=``1``    ``return` `r`  `# Function to find if any such string``# exists or not. If yes, find it``def` `find(s1, s2):``    ` `    ``x ``=` `len``(s1)``    ``y ``=` `len``(s2)``    ` `    ``# GCD of x and y``    ``gcd ``=` `math.gcd(x, y)``    ` `    ``# Form the resultant strings``    ``A ``=` `repeat(y ``/``/` `gcd, s1)``    ``B ``=` `repeat(x ``/``/` `gcd, s2)``    ` `    ``# If both the strings are same,``    ``# then print answer``    ``if` `(A ``=``=` `B):``        ``print``(A)``    ``else``:``        ``print``(``"-1"``)` `# Driver Code` `# Initializing strings``s1 ``=` `"1010"``s2 ``=` `"101010"` `find(s1, s2)`  `# This code is contributed by shivanisinghss2110`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `    ``public` `static` `int` `GCD(``int` `a, ``int` `b)``    ``{``      ` `        ``// Everything divides 0``        ``if` `(a == 0)``            ``return` `b;``        ``if` `(b == 0)``            ``return` `a;` `        ``// base case``        ``if` `(a == b)``            ``return` `a;` `        ``// a is greater``        ``if` `(a > b)``            ``return` `GCD(a - b, b);``        ``return` `GCD(a, b - a);``    ``}` `    ``public` `static` `string` `repeat(``int` `k, ``string` `S)``    ``{``        ``string` `r = ``""``;``        ``while` `(k--!=0) {``            ``r += S;``        ``}``        ``return` `r;``    ``}` `    ``// Function to find if any such string``    ``// exists or not. If yes, find it``    ``public` `static` `void` `find(``string` `s1, ``string` `s2)``    ``{``        ``int` `x = s1.Length, y = s2.Length;` `        ``// GCD of x and y``        ``int` `gcd = GCD(x, y);` `        ``// Form the resultant strings``        ``string` `A = repeat(y / gcd, s1);``        ``string` `B = repeat(x / gcd, s2);` `        ``// If both the strings are same,``        ``// then print the answer``        ``if` `(A.Equals(B)) {``            ``Console.Write(A);``        ``}``        ``else` `{``            ``Console.Write(``"-1"``);``        ``}``    ``}` `// Driver Code``public` `static` `void` `Main()``{``    ``// Initializing strings``        ``string` `s1 = ``"1010"``, s2 = ``"101010"``;` `        ``find(s1, s2);``}``}` `// This code is contributed by code_hunt.`

## Javascript

 ``

Output

`101010101010`

Time Complexity: O(m + n + log(max(m, n)))
Auxiliary Space: O(n) (For storing the strings A & B)

My Personal Notes arrow_drop_up