Open In App

Check whether a binary string can be formed by concatenating given N numbers sequentially

Last Updated : 07 Sep, 2022
Comments
Improve
Suggest changes
Like Article
Like
Report

Given a sequence of 'n' numbers (without leading zeros), the task is to find whether it is possible to create a binary string by concatenating these numbers sequentially. 
If possible, then print the binary string formed, otherwise print "-1".

Examples : 

Input: arr[] = {10, 11, 1, 0, 10} 
Output: 10111010 
All the numbers contain the digits '1' and '0' only. So it is possible to form a binary string by concatenating 
these numbers sequentially which is 10111010.

Input: arr[] = {1, 2, 11, 10} 
Output: -1 
One of the numbers contains the digit '2' which cannot be a part of any binary string. 
So, the output is -1.

Approach: The main observation is that we can only concatenate those numbers which contain the digits '1' and '0' only. Otherwise, it is impossible to form a binary string.

Below is the implementation of the above approach : 

C++ 
// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;

// Function that returns false if
// the number passed as argument contains
// digit(s) other than '0' or '1'
bool isBinary(int n)
{
    while (n != 0) {
        int temp = n % 10;
        if (temp != 0 && temp != 1) {
            return false;
        }
        n = n / 10;
    }
    return true;
}

//Function that checks whether the 
//binary string can be formed or not
void formBinaryStr(int n, int a[])
{
    bool flag = true;

    // Empty string for storing
    // the binary number
    string s = "";

    for (int i = 0; i < n; i++) {

        // check if a[i] can be a
        // part of the binary string
        if (isBinary(a[i]))

            // Conversion of int into string
            s += to_string(a[i]);
        else {

            // if a[i] can't be a part
            // then break the loop
            flag = false;
            break;
        }
    }

    // possible to create binary string
    if (flag)
        cout << s << "\n";

    // impossible to create binary string
    else
        cout << "-1\n";
}

// Driver code
int main()
{

    int a[] = { 10, 1, 0, 11, 10 };
    int N = sizeof(a) / sizeof(a[0]);

    formBinaryStr(N, a);

    return 0;
}
Java 
// Java  implementation of the approach
import java.util.*;
class Solution
{
// Function that returns false if
// the number passed as argument contains
// digit(s) other than '0' or '1'
static boolean isBinary(int n)
{
    while (n != 0) {
        int temp = n % 10;
        if (temp != 0 && temp != 1) {
            return false;
        }
        n = n / 10;
    }
    return true;
}

//Function that checks whether the 
//binary String can be formed or not
static void formBinaryStr(int n, int a[])
{
    boolean flag = true;

    // Empty String for storing
    // the binary number
    String s = "";

    for (int i = 0; i < n; i++) {

        // check if a[i] can be a
        // part of the binary String
        if (isBinary(a[i]))

            // Conversion of int into String
            s += ""+a[i];
        else {

            // if a[i] can't be a part
            // then break the loop
            flag = false;
            break;
        }
    }

    // possible to create binary String
    if (flag)
        System.out.print( s + "\n");

    // impossible to create binary String
    else
        System.out.print( "-1\n");
}

// Driver code
public static void main(String args[])
{

    int a[] = { 10, 1, 0, 11, 10 };
    int N = a.length;

    formBinaryStr(N, a);
}
}
//contributed by Arnab Kundu
Python3 
# Python3 implementation of the approach 

# Function that returns false if the 
# number passed as argument contains 
# digit(s) other than '0' or '1' 
def isBinary(n): 

    while n != 0: 
        temp = n % 10
        if temp != 0 and temp != 1: 
            return False
        
        n = n // 10
    
    return True

# Function that checks whether the 
# binary string can be formed or not 
def formBinaryStr(n, a):

    flag = True

    # Empty string for storing 
    # the binary number 
    s = "" 
    for i in range(0, n): 

        # check if a[i] can be a 
        # part of the binary string 
        if isBinary(a[i]) == True: 
            
            # Conversion of int into string 
            s += str(a[i]) 
        
        else: 
            # if a[i] can't be a part 
            # then break the loop 
            flag = False
            break

    # possible to create binary string 
    if flag == True:
        print(s) 

    # impossible to create binary string 
    else:
        cout << "-1\n"

# Driver code 
if __name__ == "__main__": 

    a = [10, 1, 0, 11, 10] 
    N = len(a) 

    formBinaryStr(N, a) 

# This code is contributed by Rituraj Jain
C# 
// C#  implementation of the approach
using System;

public class Solution
{
// Function that returns false if 
// the number passed as argument contains 
// digit(s) other than '0' or '1' 
public static bool isBinary(int n)
{
    while (n != 0)
    {
        int temp = n % 10;
        if (temp != 0 && temp != 1)
        {
            return false;
        }
        n = n / 10;
    }
    return true;
}

//Function that checks whether the  
//binary String can be formed or not 
public static void formBinaryStr(int n, int[] a)
{
    bool flag = true;

    // Empty String for storing 
    // the binary number 
    string s = "";

    for (int i = 0; i < n; i++)
    {

        // check if a[i] can be a 
        // part of the binary String 
        if (isBinary(a[i]))
        {

            // Conversion of int into String 
            s += "" + a[i];
        }
        else
        {

            // if a[i] can't be a part 
            // then break the loop 
            flag = false;
            break;
        }
    }

    // possible to create binary String 
    if (flag)
    {
        Console.Write(s + "\n");
    }

    // impossible to create binary String 
    else
    {
        Console.Write("-1\n");
    }
}

// Driver code 
public static void Main(string[] args)
{

    int[] a = new int[] {10, 1, 0, 11, 10};
    int N = a.Length;

    formBinaryStr(N, a);
}
}

// This code is contributed by Shrikant13
PHP 
<?php
// PHP implementation of the approach

// Function that returns false if the
// number passed as argument contains
// digit(s) other than '0' or '1'
function isBinary($n)
{
    while ($n != 0) 
    {
        $temp = $n % 10;
        if ($temp != 0 && $temp != 1) 
        {
            return false;
        }
        $n = intval($n / 10);
    }
    return true;
}

// Function that checks whether the 
// binary string can be formed or not
function formBinaryStr($n, &$a)
{
    $flag = true;

    // Empty string for storing
    // the binary number
    $s = "";

    for ($i = 0; $i < $n; $i++)
    {

        // check if a[i] can be a
        // part of the binary string
        if (isBinary($a[$i]))

            // Conversion of int into string
            $s = $s.strval($a[$i]);
        else 
        {

            // if a[i] can't be a part
            // then break the loop
            $flag = false;
            break;
        }
    }

    // possible to create binary string
    if ($flag)
        echo $s . "\n";

    // impossible to create binary string
    else
        echo "-1\n";
}

// Driver code
$a = array( 10, 1, 0, 11, 10 );
$N = sizeof($a) / sizeof($a[0]);

formBinaryStr($N, $a);

// This code is contributed by ita_c
?>
JavaScript 
<script>

// Javascript  implementation of the approach

    // Function that returns false if
    // the number passed as argument contains
    // digit(s) other than '0' or '1'
    function isBinary(n)
    {
        while (n != 0) {
            var temp = n % 10;
            if (temp != 0 && temp != 1) {
                return false;
            }
            n = parseInt(n / 10);
        }
        return true;
    }

    // Function that checks whether the
    // binary String can be formed or not
    function formBinaryStr(n , a) {
        var flag = true;

        // Empty String for storing
        // the binary number
        var s = "";

        for (i = 0; i < n; i++) {

            // check if a[i] can be a
            // part of the binary String
            if (isBinary(a[i]))

                // Conversion of var into String
                s += "" + a[i];
            else {

                // if a[i] can't be a part
                // then break the loop
                flag = false;
                break;
            }
        }

        // possible to create binary String
        if (flag)
            document.write(s + "\n");

        // impossible to create binary String
        else
            document.write("-1\n");
    }

    // Driver code
    

        var a = [ 10, 1, 0, 11, 10 ];
        var N = a.length;

        formBinaryStr(N, a);

// This code contributed by Rajput-Ji

</script>

Output
10101110

Complexity Analysis:

  • Time Complexity: O(N*log(MAX)), where N is the length of the array and MAX is the maximum number in the array
  • Auxiliary Complexity: O(M), where M is the length of the string

S
souradeep
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox