 GFG App
Open App Browser
Continue

# Longest common substring in binary representation of two numbers

Given two integers n and m. Find the longest contiguous subset in binary representation of both the numbers and their decimal value.

Example 1:

```Input : n = 10, m = 11
Output : 5
Explanation : Binary representation of
10 -> 1010
11 -> 1011
longest common substring in both is 101
and decimal value of 101 is 5```

Example 2:

```Input : n = 8, m = 16
Output : 8
Explanation : Binary representation of
8  -> 1000
16 -> 10000
longest common substring in both is 1000
and decimal value of 1000 is 8```

Example 3:

```Input : n = 0, m = 8
Output : 9
Explanation : Binary representation of
0  -> 0
8 -> 1000
longest common substring in both is 0
and decimal value of 0 is 0```

Prerequisite :

1. substr C++
2. find C++

We convert given numbers to their binary representations and store binary representations in two strings. Once we get strings, we find the longest common substring by trying all length substrings starting from maximum possible length.

Implementation:

## C++

 `// CPP program to find longest contiguous` `// subset in binary representation of given` `// two numbers n and m` `#include ` `using` `namespace` `std;`   `// utility function which returns` `// decimal value of binary representation` `int` `getDecimal(string s)` `{` `    ``int` `len = s.length();` `    ``int` `ans = 0;` `    ``int` `j = 0;` `    ``for` `(``int` `i = len - 1; i >= 0; i--)` `    ``{` `        ``if` `(s[i] == ``'1'``)` `            ``ans += ``pow``(2, j);` `        ``j += 1;` `    ``}` `    ``return` `ans;` `}`   `// Utility function which convert decimal` `// number to its binary representation` `string convertToBinary(``int` `n)` `{` `    ``string temp;` `    ``while` `(n > 0)` `    ``{` `        ``int` `rem = n % 2;` `        ``temp.push_back(48 + rem);` `        ``n = n / 2;` `    ``}` `    ``reverse(temp.begin(), temp.end());` `    ``return` `temp;` `}`   `// utility function to check all the` `// substrings and get the longest substring.` `int` `longestCommon(``int` `n, ``int` `m)` `{` `    ``int` `mx = -INT_MAX; ``// maximum length` `    ``string s1 = convertToBinary(n);` `    ``string s2 = convertToBinary(m);`   `    ``string res; ``// final resultant string` `    ``int` `len = s1.length();` `    ``int` `l = len;`   `    ``// for every substring of s1,` `    ``// check if its length is greater than` `    ``// previously found string` `    ``// and also it is present in string s2` `    ``while` `(len > 0)` `    ``{` `        ``for` `(``int` `i = 0; i < l - len + 1; i++)` `        ``{` `            ``string temp = s1.substr(i, len);`   `            ``int` `tlen = temp.length();` `            ``if` `(tlen > mx && s2.find(temp) != string::npos)` `            ``{` `                ``res = temp;` `                ``mx = tlen;` `            ``}` `        ``}` `        ``len = len - 1;` `    ``}`   `    ``// If there is no common string` `    ``if` `(res == ``""``)` `        ``return` `-1;`   `    ``return` `getDecimal(res);` `}`   `// driver program` `int` `main()` `{` `    ``int` `n = 10, m = 11;` `    ``cout << ``"longest common decimal value : "` `         ``<< longestCommon(m, n) << endl;` `    ``return` `0;` `}`

## Java

 `// Java program to find longest contiguous` `// subset in binary representation of given` `// two numbers n and m` `public` `class` `GFG` `{    ` `    ``// utility function to check all the` `    ``// substrings and get the longest substring.` `    ``static` `int` `longestCommon(``int` `n, ``int` `m)` `    ``{ ` `        ``int` `mx = -Integer.MAX_VALUE; ``// maximum length` `        ``String s1 = Integer.toBinaryString(n);` `        ``String s2 = Integer.toBinaryString(m);` `        `  `        ``String res = ``null``;  ``// final resultant string` `        ``int` `len = s1.length();` `        ``int` `l = len;` `        `  `        ``// for every substring of s1,` `        ``// check if its length is greater than` `        ``// previously found string` `        ``// and also it is present in string s2` `        ``while` `(len > ``0``)` `        ``{` `            ``for` `(``int` `i = ``0``; i < l - len + ``1``; i++)` `            ``{` `                ``String temp = s1.substring(i, i + len);` `                `  `                ``int` `tlen = temp.length();` `                ``if` `(tlen > mx && s2.contains(temp))` `                ``{` `                    ``res = temp;` `                    ``mx = tlen;` `                ``}` `            ``}` `            `  `            ``len = len - ``1``;` `        ``}` `        `  `        ``// If there is no common string` `        ``if``(res == ``""``)` `            ``return` `-``1``;` `        `  `        ``return` `Integer.parseInt(res,``2``);` `    ``}` `    `  `    ``// driver program to test above function` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``int` `n = ``10``;` `        ``int` `m = ``11``;` `        ``System.out.println(``"Longest common decimal value : "` `                            ``+longestCommon(m, n));` `    ``}` `}`   `// This code is Contributed by Sumit Ghosh`

## Python3

 `# Python3 program to find longest contiguous` `# subset in binary representation of given` `# two numbers n and m`   `# utility function which returns` `# decimal value of binary representation` `def` `getDecimal(s):` `    ``lenn ``=` `len``(s)` `    ``ans ``=` `0` `    ``j ``=` `0` `    ``for` `i ``in` `range``(lenn ``-` `1``, ``-``1``, ``-``1``):` `        ``if` `(s[i] ``=``=` `'1'``):` `            ``ans ``+``=` `pow``(``2``, j)` `        ``j ``+``=` `1` `    ``return` `ans`   `# Utility function which convert decimal` `# number to its binary representation` `def` `convertToBinary(n):`   `    ``return` `bin``(n)[``2``:]`   `# utility function to check all the` `# substrings and get the longest substring.` `def` `longestCommon(n, m):` `    ``mx ``=` `-``10``*``*``9` `# maximum length` `    ``s1 ``=` `convertToBinary(n)` `    ``s2 ``=` `convertToBinary(m)` `    ``#print(s1,s2)`   `    ``res``=``"" ``# final resultant string` `    ``lenn ``=` `len``(s1)` `    ``l ``=` `lenn`   `    ``# for every subof s1,` `    ``# check if its length is greater than` `    ``# previously found string` `    ``# and also it is present in s2` `    ``while` `(lenn > ``0``):`   `        ``for` `i ``in` `range``(l ``-` `lenn ``+` `1``):`   `            ``temp ``=` `s1[i:lenn ``+` `1``]` `            ``# print(temp)`   `            ``tlenn ``=` `len``(temp)`   `            ``if` `(tlenn > mx ``and``( s2.find(temp) !``=` `-``1``)):` `                ``res ``=` `temp` `                ``mx ``=` `tlenn`   `        ``lenn ``=` `lenn ``-` `1`   `    ``# If there is no common string` `    ``if` `(res ``=``=` `""):` `        ``return` `-``1`   `    ``return` `getDecimal(res)`   `# Driver Code` `n ``=` `10` `m ``=` `11` `print``(``"longest common decimal value : "``,` `                    ``longestCommon(m, n))`   `# This code is contributed by Mohit Kumar`

## C#

 `// C# program to find longest contiguous ` `// subset in binary representation of given ` `// two numbers n and m ` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG ` `{ ` `    ``// utility function to check all the ` `    ``// substrings and get the longest substring. ` `    ``static` `int` `longestCommon(``int` `n, ``int` `m) ` `    ``{ ` `        ``int` `mx = -``int``.MaxValue; ``// maximum length ` `        ``String s1 = Convert.ToString(n, 2);` `        ``String s2 = Convert.ToString(m, 2);; ` `        `  `        ``String res = ``null``; ``// final resultant string ` `        ``int` `len = s1.Length; ` `        ``int` `l = len; ` `        `  `        ``// for every substring of s1, ` `        ``// check if its length is greater than ` `        ``// previously found string ` `        ``// and also it is present in string s2 ` `        ``while` `(len > 0) ` `        ``{ ` `            ``for` `(``int` `i = 0; i < l - len + 1; i++) ` `            ``{ ` `                ``String temp = s1.Substring(i, len); ` `                `  `                ``int` `tlen = temp.Length; ` `                ``if` `(tlen > mx && s2.Contains(temp)) ` `                ``{ ` `                    ``res = temp; ` `                    ``mx = tlen; ` `                ``} ` `            ``} ` `            `  `            ``len = len - 1; ` `        ``} ` `        `  `        ``// If there is no common string ` `        ``if``(res == ``""``) ` `            ``return` `-1; ` `        `  `        ``return` `Convert.ToInt32(res, 2); ` `    ``} ` `    `  `    ``// Driver code` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `        ``int` `n = 10; ` `        ``int` `m = 11; ` `        ``Console.WriteLine(``"Longest common decimal value : "` `                            ``+longestCommon(m, n)); ` `    ``} ` `} `   `// This code contributed by Rajput-Ji`

## Javascript

 ``

Output

`longest common decimal value : 5`

Optimizations to above approach:
The above solution can be optimized by methods discussed in below posts:
Dynamic Programming | Set 29 (Longest Common Substring)

This article is contributed by Mandeep Singh. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up