Related Articles

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

• Last Updated : 21 May, 2021

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

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``?>`

## Javascript

 ``

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.  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.

My Personal Notes arrow_drop_up