Largest Prime Number possible from a subsequence of a Binary String

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: 5 
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 j^th 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 <iostream>
#include <vector>
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<pair<string, int> > 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<string, int> 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<StringIntPair> 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<Tuple<string, int> > vec
      = new List<Tuple<string, int> >();
    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

<script>

// JavaScript Program to implement
// the above approach

// Function to check if a
// number is prime or not
function isPrime(x) {
    if (x <= 1)
        return false;

    for (let i = 2; i * i <= x; i++) {
        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
function largestPrime(s) {

    // Stores pairs of subsequences and
    // their respective decimal value
    let vec = [["", 0]];

    // Stores the answer
    let ans = 0;

    // Traverse the string
    for (let i = 0; i < s.length; i++) {
        // Stores the size of the vector
        let n = vec.length;

        // Traverse the vector
        for (let j = 0; j < n; j++) {

            // Extract the current pair
            let temp = vec[j];

            // Get the binary string from the pair
            let str = temp[0];

            // Stores equivalent decimal values
            let 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.push(temp);

            // Check if the decimal
            // representation of current
            // subsequence is prime or not
            let check = temp[1];

            // If prime
            if (isPrime(check)) {
                // Update the answer
                // with the largest one
                ans = Math.max(ans, check);
                break
            }
        }
    }

    // If no prime number
    // could be obtained
    if (ans == 0)
        document.write(-1 + "<br>");
    else
        document.write(ans + "<br>");
}

// Driver Code

// Input String
let s = "110";

largestPrime(s);

</script>

Output:

3

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