# Largest Prime Number possible from a subsequence of a Binary String

• Difficulty Level : Medium
• Last Updated : 01 Feb, 2023

Given a Binary string, the task is to find the largest Prime Number possible by the decimal representation of a subsequence of the given binary string. If no prime number can be obtained, print -1.

Examples:

Input: S = “1001”
Output:
Explanation: Out of all subsequences of the string “1001”, the largest prime number that can be obtained is “101” (= 5).

Input: “1011”
Output: 11
Explanation: Out of all subsequences of the string “1011”, the largest prime number that can be obtained is “1011” (= 11).

Approach:  To solve the problem, the idea is to generate all possible subsequences of the string, and convert each subsequence to its equivalent decimal form. Print the largest prime number obtained from this subsequences.

Follow the steps below to solve this problem:

• Initialize a vector of pairs, say vec, for storing pairs of strings and their equivalent decimal values, in Pair.first and Pair.second respectively.
• Initialize a variable, say ans, to store the required answer.
• Iterate a loop from i = 0 to length of the string s:
• Iterate a loop from j = 0 to the length of vec:
• Store the jth pair in temp.
• If the ith character of string s is ‘1‘:
• Add the character in temp.first.
• Update the value of temp.second by left shifting the current value and adding 1 to it.
• Otherwise:
• Add the character in temp.first.
• Update the value of temp.second by left shifting the current value and adding 0 to it.
• Store this temp pair into vec.
• If the temp.second is prime:
• Store max of ans and temp.second in ans.
• If ans is equal to 0:
• No prime number can be obtained from the string s.
• Otherwise:
• Print ans.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement``// the above approach` `#include ``#include ``using` `namespace` `std;` `// Function to check if a``// number is prime or not``bool` `isPrime(``int` `x)``{``    ``if` `(x <= 1)``        ``return` `false``;` `    ``for` `(``int` `i = 2; i * i <= x; i++) {``        ``if` `(x % i == 0)` `            ``// Return not prime``            ``return` `false``;``    ``}` `    ``// If prime return true``    ``return` `true``;``}` `// Function to find the largest prime``// number possible from a subsequence``void` `largestPrime(string s)``{` `    ``// Stores pairs of subsequences and``    ``// their respective decimal value``    ``vector > vec{ { ``""``, 0 } };` `    ``// Stores the answer``    ``int` `ans = 0;` `    ``// Traverse the string``    ``for` `(``int` `i = 0; i < s.length(); i++) {``        ``// Stores the size of the vector``        ``int` `n = vec.size();` `        ``// Traverse the vector``        ``for` `(``int` `j = 0; j < n; j++) {` `            ``// Extract the current pair``            ``pair temp = vec[j];` `            ``// Get the binary string from the pair``            ``string str = temp.first;` `            ``// Stores equivalent decimal values``            ``int` `val = temp.second;` `            ``// If the current character is '1'``            ``if` `(s[i] == ``'1'``) {``                ``// Add the character``                ``// to the subsequence``                ``temp.first = str + ``'1'``;` `                ``// Update the value by left``                ``// shifting the current``                ``// value and adding 1 to it``                ``temp.second = ((val << 1) + 1);``            ``}` `            ``// If s[i]=='0'``            ``else` `{` `                ``// Add the character``                ``// to the subsequence``                ``temp.first = str + ``'0'``;` `                ``// Update the value by left``                ``// shifting the current``                ``// value and adding 0 to it``                ``temp.second = ((val << 1) + 0);``            ``}` `            ``// Store the subsequence in the vector``            ``vec.push_back(temp);` `            ``// Check if the decimal``            ``// representation of current``            ``// subsequence is prime or not``            ``int` `check = temp.second;` `            ``// If prime``            ``if` `(isPrime(check)) {``                ``// Update the answer``                ``// with the largest one``                ``ans = max(ans, check);``            ``}``        ``}``    ``}` `    ``// If no prime number``    ``// could be obtained``    ``if` `(ans == 0)``        ``cout << -1 << endl;``    ``else``        ``cout << ans << endl;``}` `// Driver Code``int` `main()``{``    ``// Input String``    ``string s = ``"110"``;` `    ``largestPrime(s);` `    ``return` `0;``}`

## Java

 `// Java code to implement the approach``import` `java.util.*;` `class` `GFG {` `    ``// Function to check if a``    ``// number is prime or not``    ``static` `boolean` `isPrime(``int` `x)``    ``{``        ``if` `(x <= ``1``)``            ``return` `false``;` `        ``for` `(``int` `i = ``2``; i * i <= x; i++) {``            ``if` `(x % i == ``0``)``                ``// Return not prime``                ``return` `false``;``        ``}` `        ``// If prime return true``        ``return` `true``;``    ``}` `    ``// Function to find the largest prime``    ``// number possible from a subsequence``    ``static` `void` `largestPrime(String s)``    ``{` `        ``// Stores pairs of subsequences and``        ``// their respective decimal value``        ``List vec = ``new` `ArrayList<>();``        ``vec.add(``new` `StringIntPair(``""``, ``0``));` `        ``// Stores the answer``        ``int` `ans = ``0``;` `        ``// Traverse the string``        ``for` `(``int` `i = ``0``; i < s.length(); i++) {``            ``// Stores the size of the vector``            ``int` `n = vec.size();` `            ``// Traverse the vector``            ``for` `(``int` `j = ``0``; j < n; j++) {``                ``// Extract the current pair``                ``StringIntPair ele = vec.get(j);``                ``String str = ele.str;``                ``int` `val = ele.val;` `                ``// If the current character is '1'``                ``if` `(s.charAt(i) == ``'1'``) {``                    ``// Add the character``                    ``// to the subsequence``                    ``str = str + ``'1'``;` `                    ``// Update the value by left``                    ``// shifting the current``                    ``// value and adding 1 to it``                    ``val = ((val << ``1``) + ``1``);``                ``}``                ``// If s[i]=='0'``                ``else` `{``                    ``// Add the character``                    ``// to the subsequence``                    ``str = str + ``'0'``;` `                    ``// Update the value by left``                    ``// shifting the current``                    ``// value and adding 0 to it``                    ``val = ((val << ``1``) + ``0``);``                ``}` `                ``// Store the subsequence in the vector``                ``vec.add(``new` `StringIntPair(str, val));` `                ``// Check if the decimal``                ``// representation of current``                ``// subsequence is prime or not``                ``int` `check = val;` `                ``// If prime``                ``if` `(isPrime(check)) {``                    ``// Update the answer``                    ``// with the largest one``                    ``ans = Math.max(ans, check);``                ``}``            ``}``        ``}` `        ``// If no prime number``        ``// could be obtained``        ``if` `(ans == ``0``)``            ``System.out.println(-``1``);``        ``else``            ``System.out.println(ans);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``// Input String``        ``String s = ``"110"``;``        ``largestPrime(s);``    ``}` `    ``// Class to store pairs of strings and integers``    ``static` `class` `StringIntPair {``        ``String str;``        ``int` `val;` `        ``StringIntPair(String str, ``int` `val)``        ``{``            ``this``.str = str;``            ``this``.val = val;``        ``}``    ``}``}` `// This code is contributed by phasing17.`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to check if a``# number is prime or not``def` `isPrime(x):``    ` `    ``if` `(x <``=` `1``):``        ``return` `False` `    ``for` `i ``in` `range``(``2``, x ``+` `1``):``        ``if` `i ``*` `i > x:``            ``break``        ` `        ``if` `(x ``%` `i ``=``=` `0``):``            ` `            ``# Return not prime``            ``return` `False` `    ``# If prime return true``    ``return` `True` `# Function to find the largest prime``# number possible from a subsequence``def` `largestPrime(s):` `    ``# Stores pairs of subsequences and``    ``# their respective decimal value``    ``vec ``=` `[["", ``0``]]``    ` `    ``# Stores the answer``    ``ans ``=` `0` `    ``# Traverse the string``    ``for` `i ``in` `range``(``len``(s)):``        ` `        ``# Stores the size of the vector``        ``n ``=` `len``(vec)` `        ``# Traverse the vector``        ``for` `j ``in` `range``(n):``            ` `            ``# Extract the current pair``            ``temp ``=` `vec[j]` `            ``# Get the binary string from the pair``            ``str` `=` `temp[``0``]` `            ``# Stores equivalent decimal values``            ``val ``=` `temp[``1``]` `            ``# If the current character is '1'``            ``if` `(s[i] ``=``=` `'1'``):``                ` `                ``# Add the character``                ``# to the subsequence``                ``temp[``0``] ``=` `str` `+` `'1'` `                ``# Update the value by left``                ``# shifting the current``                ``# value and adding 1 to it``                ``temp[``1``] ``=` `((val << ``1``) ``+` `1``)` `            ``# If s[i]=='0'``            ``else``:` `                ``# Add the character``                ``# to the subsequence``                ``temp[``0``] ``=` `str` `+` `'0'` `                ``# Update the value by left``                ``# shifting the current``                ``# value and adding 0 to it``                ``temp[``1``] ``=` `((val << ``1``) ``+` `0``)` `            ``# Store the subsequence in the vector``            ``vec.append(temp)` `            ``# Check if the decimal``            ``# representation of current``            ``# subsequence is prime or not``            ``check ``=` `temp[``1``]` `            ``# If prime``            ``if` `(isPrime(check)):``                ` `                ``# Update the answer``                ``# with the largest one``                ``ans ``=` `max``(ans, check)``                ``break` `    ``# If no prime number``    ``# could be obtained``    ``if` `(ans ``=``=` `0``):``        ``print``(``-``1``)``    ``else``:``        ``print``(ans)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Input String``    ``s ``=` `"110"` `    ``largestPrime(s)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# code to implement the approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `  ``// Function to check if a``  ``// number is prime or not``  ``static` `bool` `IsPrime(``int` `x)``  ``{``    ``if` `(x <= 1)``      ``return` `false``;` `    ``for` `(``int` `i = 2; i * i <= x; i++) {``      ``if` `(x % i == 0)``        ``// Return not prime``        ``return` `false``;``    ``}` `    ``// If prime return true``    ``return` `true``;``  ``}` `  ``// Function to find the largest prime``  ``// number possible from a subsequence``  ``static` `void` `LargestPrime(``string` `s)``  ``{` `    ``// Stores pairs of subsequences and``    ``// their respective decimal value``    ``List > vec``      ``= ``new` `List >();``    ``vec.Add(Tuple.Create(``""``, 0));` `    ``// Stores the answer``    ``int` `ans = 0;` `    ``// Traverse the string``    ``for` `(``int` `i = 0; i < s.Length; i++) {``      ``// Stores the size of the vector``      ``int` `n = vec.Count;` `      ``// Traverse the vector``      ``for` `(``int` `j = 0; j < n; j++) {``        ``// Extract the current pair``        ``var` `ele = vec[j];``        ``string` `str = ele.Item1;``        ``int` `val = ele.Item2;` `        ``// If the current character is '1'``        ``if` `(s[i] == ``'1'``) {``          ``// Add the character``          ``// to the subsequence``          ``str = str + ``'1'``;` `          ``// Update the value by left``          ``// shifting the current``          ``// value and adding 1 to it``          ``val = ((val << 1) + 1);``        ``}``        ``// If s[i]=='0'``        ``else` `{``          ``// Add the character``          ``// to the subsequence``          ``str = str + ``'0'``;` `          ``// Update the value by left``          ``// shifting the current``          ``// value and adding 0 to it``          ``val = ((val << 1) + 0);``        ``}` `        ``// Store the subsequence in the vector``        ``vec.Add(Tuple.Create(str, val));` `        ``// Check if the decimal``        ``// representation of current``        ``// subsequence is prime or not``        ``int` `check = val;` `        ``// If prime``        ``if` `(IsPrime(check)) {``          ``// Update the answer``          ``// with the largest one``          ``ans = Math.Max(ans, check);``        ``}``      ``}``    ``}` `    ``// If no prime number``    ``// could be obtained``    ``if` `(ans == 0)``      ``Console.WriteLine(-1);``    ``else``      ``Console.WriteLine(ans);``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(``string``[] args)``  ``{` `    ``// Input String``    ``string` `s = ``"110"``;``    ``LargestPrime(s);``  ``}``}` `// This code is contributed by phasing17`

## Javascript

 ``

Output:

`3`

Time Complexity: O(2N * √N), where N is the length of the string.
Auxiliary Space: O(2N * N)

My Personal Notes arrow_drop_up