# Decimal representation of given binary string is divisible by 20 or not

The problem is to check whether the decimal representation of the given binary number is divisible by 20 or not. Take care, the number could be very large and may not fit even in long long int. The approach should be such that there are zero or minimum number of multiplication and division operations. No leading 0’s are there in the input.

Examples :

```Input : 101000
Output : Yes
(10100)2 = (40)10
and 40 is divisible by 20.

Input : 110001110011100
Output : Yes
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: Following are the steps:

1. Let the binary string be bin[].
2. Let the length of bin[] be n.
3. If bin[n-1] == ‘1’, then it is an odd number and thus not divisible by 20.
4. Else check if bin[0..n-2] is divisible by 10. Refer this post.

## C++

 `// C++ implementation to check whether  ` `// decimal representation of given binary ` `// number is divisible by 20 or not ` `#include ` `using` `namespace` `std; ` ` `  `// function to check whether decimal ` `// representation of given binary number ` `// is divisible by 10 or not ` `bool` `isDivisibleBy10(``char` `bin[], ``int` `n) ` `{ ` `    ``// if last digit is '1', then ` `    ``// number is not divisible by 10 ` `    ``if` `(bin[n - 1] == ``'1'``) ` `        ``return` `false``; ` ` `  `    ``// to accumulate the sum of last digits ` `    ``// in perfect powers of 2 ` `    ``int` `sum = 0; ` ` `  `    ``// traverse from the 2nd last up  ` `    ``// to 1st digit in 'bin' ` `    ``for` `(``int` `i = n - 2; i >= 0; i--) { ` ` `  `        ``// if digit in '1' ` `        ``if` `(bin[i] == ``'1'``) { ` ` `  `            ``// calculate digit's position from ` `            ``// the right ` `            ``int` `posFromRight = n - i - 1; ` ` `  `            ``// according to the digit's position, ` `            ``// obtain the last digit of the  ` `            ``// applicable perfect power of 2 ` `            ``if` `(posFromRight % 4 == 1) ` `                ``sum = sum + 2; ` `            ``else` `if` `(posFromRight % 4 == 2) ` `                ``sum = sum + 4; ` `            ``else` `if` `(posFromRight % 4 == 3) ` `                ``sum = sum + 8; ` `            ``else` `if` `(posFromRight % 4 == 0) ` `                ``sum = sum + 6; ` `        ``} ` `    ``} ` ` `  `    ``// if last digit is 0, then ` `    ``// divisible by 10 ` `    ``if` `(sum % 10 == 0) ` `        ``return` `true``; ` ` `  `    ``// not divisible by 10 ` `    ``return` `false``; ` `} ` ` `  `// function to check whether decimal ` `// representation of given binary number  ` `// is divisible by 20 or not ` `bool` `isDivisibleBy20(``char` `bin[], ``int` `n) ` `{ ` `    ``// if 'bin' is an odd number ` `    ``if` `(bin[n - 1] == ``'1'``) ` `        ``return` `false``; ` ` `  `    ``// check if bin(0..n-2) is divisible ` `    ``// by 10 or not ` `    ``return` `isDivisibleBy10(bin, n - 1); ` `} ` ` `  `// Driver program to test above ` `int` `main() ` `{ ` `    ``char` `bin[] = ``"101000"``; ` `    ``int` `n = ``sizeof``(bin) / ``sizeof``(bin); ` ` `  `    ``if` `(isDivisibleBy20(bin, n - 1)) ` `        ``cout << ``"Yes"``; ` `    ``else` `        ``cout << ``"No"``; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation to check whether  ` `// decimal representation of given binary ` `// number is divisible by 20 or not ` `import` `java.io.*; ` ` `  `class` `GFG { ` `     `  `    ``// function to check whether decimal ` `    ``// representation of given binary number ` `    ``// is divisible by 10 or not ` `    ``static` `boolean` `isDivisibleBy10(``char` `bin[], ``int` `n) ` `    ``{ ` `        ``// if last digit is '1', then ` `        ``// number is not divisible by 10 ` `        ``if` `(bin[n - ``1``] == ``'1'``) ` `            ``return` `false``; ` `     `  `        ``// to accumulate the sum of last  ` `        ``// digits in perfect powers of 2 ` `        ``int` `sum = ``0``; ` `     `  `        ``// traverse from the 2nd last up  ` `        ``// to 1st digit in 'bin' ` `        ``for` `(``int` `i = n - ``2``; i >= ``0``; i--) { ` `     `  `            ``// if digit in '1' ` `            ``if` `(bin[i] == ``'1'``) { ` `     `  `                ``// calculate digit's position from ` `                ``// the right ` `                ``int` `posFromRight = n - i - ``1``; ` `     `  `                ``// according to the digit's position, ` `                ``// obtain the last digit of the  ` `                ``// applicable perfect power of 2 ` `                ``if` `(posFromRight % ``4` `== ``1``) ` `                    ``sum = sum + ``2``; ` `                ``else` `if` `(posFromRight % ``4` `== ``2``) ` `                    ``sum = sum + ``4``; ` `                ``else` `if` `(posFromRight % ``4` `== ``3``) ` `                    ``sum = sum + ``8``; ` `                ``else` `if` `(posFromRight % ``4` `== ``0``) ` `                    ``sum = sum + ``6``; ` `            ``} ` `        ``} ` `     `  `        ``// if last digit is 0, then ` `        ``// divisible by 10 ` `        ``if` `(sum % ``10` `== ``0``) ` `            ``return` `true``; ` `     `  `        ``// not divisible by 10 ` `        ``return` `false``; ` `    ``} ` `     `  `    ``// function to check whether decimal ` `    ``// representation of given binary number  ` `    ``// is divisible by 20 or not ` `    ``static` `boolean` `isDivisibleBy20(``char` `bin[], ``int` `n) ` `    ``{ ` `        ``// if 'bin' is an odd number ` `        ``if` `(bin[n - ``1``] == ``'1'``) ` `            ``return` `false``; ` `     `  `        ``// check if bin(0..n-2) is divisible ` `        ``// by 10 or not ` `        ``return` `isDivisibleBy10(bin, n - ``1``); ` `    ``} ` `     `  `    ``// Driver program to test above ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``char` `bin[] = ``"101000"``.toCharArray(); ` `        ``int` `n = bin.length; ` `     `  `        ``if` `(isDivisibleBy20(bin, n - ``1``)) ` `            ``System.out.println(``"Yes"``); ` `        ``else` `            ``System.out.println(``"No"``); ` `    ``} ` `} ` ` `  ` `  `// This code is contributed  ` `// by Nikita Tiwari. `

## Python3

 `# Python 3 implementation to check whether  ` `# decimal representation of given binary ` `# number is divisible by 20 or not ` ` `  `# function to check whether decimal ` `# representation of given binary number ` `# is divisible by 10 or not ` `def` `isDivisibleBy10(``bin``, n): ` ` `  `    ``# if last digit is '1', then ` `    ``# number is not divisible by 10 ` `    ``if` `(``bin``[n ``-` `1``] ``=``=` `'1'``): ` `        ``return` `False` ` `  `    ``# to accumulate the sum of last digits ` `    ``# in perfect powers of 2 ` `    ``sum` `=` `0` ` `  `    ``# traverse from the 2nd last up  ` `    ``# to 1st digit in 'bin' ` `    ``for` `i ``in` `range``(n ``-` `2``, ``-``1``, ``-``1``):  ` ` `  `        ``# if digit in '1' ` `        ``if` `(``bin``[i] ``=``=` `'1'``) : ` ` `  `            ``# calculate digit's position from ` `            ``# the right ` `            ``posFromRight ``=` `n ``-` `i ``-` `1` ` `  `            ``# according to the digit's position, ` `            ``# obtain the last digit of the  ` `            ``# applicable perfect power of 2 ` `            ``if` `(posFromRight ``%` `4` `=``=` `1``): ` `                ``sum` `=` `sum` `+` `2` `            ``elif` `(posFromRight ``%` `4` `=``=` `2``): ` `                ``sum` `=` `sum` `+` `4` `            ``elif` `(posFromRight ``%` `4` `=``=` `3``): ` `                ``sum` `=` `sum` `+` `8` `            ``elif` `(posFromRight ``%` `4` `=``=` `0``): ` `                ``sum` `=` `sum` `+` `6` `         `  `     `  ` `  `    ``# if last digit is 0, then ` `    ``# divisible by 10 ` `    ``if` `(``sum` `%` `10` `=``=` `0``): ` `        ``return` `True` ` `  `    ``# not divisible by 10 ` `    ``return` `False` ` `  ` `  `# function to check whether decimal ` `# representation of given binary number  ` `# is divisible by 20 or not ` `def` `isDivisibleBy20(``bin``, n): ` ` `  `    ``# if 'bin' is an odd number ` `    ``if` `(``bin``[n ``-` `1``] ``=``=` `'1'``): ` `        ``return` `false ` ` `  `    ``# check if bin(0..n-2) is divisible ` `    ``# by 10 or not ` `    ``return` `isDivisibleBy10(``bin``, n ``-` `1``) ` ` `  ` `  `# Driver program to test above ` `bin` `=` `[``'1'``,``'0'``,``'1'``,``'0'``,``'0'``,``'0'``] ` `n ``=` `len``(``bin``)  ` `if` `(isDivisibleBy20(``bin``, n ``-` `1``)): ` `    ``print``(``"Yes"``) ` `else``: ` `    ``print``(``"No"``) ` ` `  `# This code is contributed by Smitha Dinesh Semwal `

## C#

 `// C# implementation to check whether  ` `// decimal representation of given binary ` `// number is divisible by 20 or not ` `using` `System; ` ` `  `class` `GFG { ` `     `  `    ``// function to check whether decimal ` `    ``// representation of given binary number ` `    ``// is divisible by 10 or not ` `    ``static` `bool` `isDivisibleBy10(``string` `bin, ``int` `n) ` `    ``{ ` `        ``// if last digit is '1', then ` `        ``// number is not divisible by 10 ` `        ``if` `(bin[n - 1] == ``'1'``) ` `            ``return` `false``; ` `     `  `        ``// to accumulate the sum of last  ` `        ``// digits in perfect powers of 2 ` `        ``int` `sum = 0; ` `     `  `        ``// traverse from the 2nd last up  ` `        ``// to 1st digit in 'bin' ` `        ``for` `(``int` `i = n - 2; i >= 0; i--) { ` `     `  `            ``// if digit in '1' ` `            ``if` `(bin[i] == ``'1'``) { ` `     `  `                ``// calculate digit's position from ` `                ``// the right ` `                ``int` `posFromRight = n - i - 1; ` `     `  `                ``// according to the digit's position, ` `                ``// obtain the last digit of the  ` `                ``// applicable perfect power of 2 ` `                ``if` `(posFromRight % 4 == 1) ` `                    ``sum = sum + 2; ` `                ``else` `if` `(posFromRight % 4 == 2) ` `                    ``sum = sum + 4; ` `                ``else` `if` `(posFromRight % 4 == 3) ` `                    ``sum = sum + 8; ` `                ``else` `if` `(posFromRight % 4 == 0) ` `                    ``sum = sum + 6; ` `            ``} ` `        ``} ` `     `  `        ``// if last digit is 0, then ` `        ``// divisible by 10 ` `        ``if` `(sum % 10 == 0) ` `            ``return` `true``; ` `     `  `        ``// not divisible by 10 ` `        ``return` `false``; ` `    ``} ` `     `  `    ``// function to check whether decimal ` `    ``// representation of given binary number  ` `    ``// is divisible by 20 or not ` `    ``static` `bool` `isDivisibleBy20(``string` `bin, ``int` `n) ` `    ``{ ` `        ``// if 'bin' is an odd number ` `        ``if` `(bin[n - 1] == ``'1'``) ` `            ``return` `false``; ` `     `  `        ``// check if bin(0..n-2) is divisible ` `        ``// by 10 or not ` `        ``return` `isDivisibleBy10(bin, n - 1); ` `    ``} ` `     `  `    ``// Driver program to test above ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``string` `bin = ``"101000"``; ` `        ``int` `n = bin.Length; ` `     `  `        ``if` `(isDivisibleBy20(bin, n - 1)) ` `        ``Console.WriteLine(``"Yes"``); ` `        ``else` `            ``Console.WriteLine(``"No"``); ` `    ``} ` `} ` ` `  ` `  `// This code is contributed  ` `// by vt_m. `

## PHP

 `= 0; ``\$i``--)  ` `    ``{ ` ` `  `        ``// if digit in '1' ` `        ``if` `(``\$bin``[``\$i``] == ``'1'``)  ` `        ``{ ` ` `  `            ``// calculate digit's position  ` `            ``// from the right ` `            ``\$posFromRight` `= ``\$n` `- ``\$i` `- 1; ` ` `  `            ``// according to the digit's position, ` `            ``// obtain the last digit of the  ` `            ``// applicable perfect power of 2 ` `            ``if` `(``\$posFromRight` `% 4 == 1) ` `                ``\$sum` `= ``\$sum` `+ 2; ` `            ``else` `if` `(``\$posFromRight` `% 4 == 2) ` `                ``\$sum` `= ``\$sum` `+ 4; ` `            ``else` `if` `(``\$posFromRight` `% 4 == 3) ` `                ``\$sum` `= ``\$sum` `+ 8; ` `            ``else` `if` `(``\$posFromRight` `% 4 == 0) ` `                ``\$sum` `= ``\$sum` `+ 6; ` `        ``} ` `    ``} ` ` `  `    ``// if last digit is 0, then ` `    ``// divisible by 10 ` `    ``if` `(``\$sum` `% 10 == 0) ` `        ``return` `true; ` ` `  `    ``// not divisible by 10 ` `    ``return` `false; ` `} ` ` `  `// function to check whether decimal ` `// representation of given binary number  ` `// is divisible by 20 or not ` `function` `isDivisibleBy20(``\$bin``, ``\$n``) ` `{ ` `    ``// if 'bin' is an odd number ` `    ``if` `(``\$bin``[``\$n` `- 1] == ``'1'``) ` `        ``return` `false; ` ` `  `    ``// check if bin(0..n-2) is divisible ` `    ``// by 10 or not ` `    ``return` `isDivisibleBy10(``\$bin``, ``\$n` `- 1); ` `} ` ` `  `// Driver code ` `\$bin``= ``"101000"``; ` `\$n` `= ``strlen``(``\$bin``); ` ` `  `if` `(isDivisibleBy20(``\$bin``, ``\$n` `- 1)) ` `    ``echo` `"Yes"``; ` `else` `    ``echo` `"No"``; ` ` `  `// This code is contributed by mits  ` `?> `

Output :

```Yes
```

Time Complexity: O(n), where n is the number of digits in the binary number.

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : Mithun Kumar

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.