 Open in App
Not now

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

• Last Updated : 24 Mar, 2023

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 the minimum numbers of multiplication and division operations. No leadings 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:

1. Initialize a variable ‘dec’ to 0, which will store the decimal value of the binary number.
2. Traverse the binary number from left to right and for each digit, multiply the current value of ‘dec’ by 2 and add the current binary digit (0 or 1) to it.
3. After the traversal is complete, the final value of ‘dec’ will be the decimal representation of the binary number.

Once we have the decimal representation of the binary number, we can check whether it is divisible by 20 by using the modulo operator (%). If the decimal representation is divisible by 20, then the binary number is also divisible by 20.

Implementation:

## 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 20 or not` `bool` `isDivisibleBy20(``char` `bin[], ``int` `n)` `{` `    ``// convert binary number to decimal` `    ``int` `dec = 0;` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``dec = dec * 2 + (bin[i] - ``'0'``);` `    ``}`   `    ``// check if decimal representation is divisible by 20` `    ``if` `(dec % 20 == 0) {` `        ``return` `true``;` `    ``}` `    ``else` `{` `        ``return` `false``;` `    ``}` `}`   `// 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;` `}`

Output: Yes

Time Complexity: O(N)
Space Complexity: O(1)

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 to 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.
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles