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

• Last Updated : 13 May, 2021

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.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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 ``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);` `    ``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

 ``

## Javascript

 ``
Output:
`10101110`

My Personal Notes arrow_drop_up