Skip to content
Related Articles

Related Articles

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

View Discussion
Improve Article
Save Article
Like Article
  • Last Updated : 24 May, 2022

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

 

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

Auxiliary Space: O(M), where M is the length of the string


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!