Related Articles

# Check if Decimal representation of given Binary String is divisible by K or not

• Last Updated : 03 Aug, 2021

Given a binary string S, the task is to find that the decimal representation of the given binary string is divisible by integer K or not.

Examples:

Input: S = 1010,  k = 5
Output: Yes
Explanation: Decimal representation of 1010 (=10) is divisible by 5

Input: S = 1010,  k = 6
Output: No

Approach:  Since the modulo operator is distributive over addition, the given binary string can be checked bit by bit to see whether the decimal % k is equal to zero or not. Follow the steps below for the approach:

• Initialize an array poweroftwo[], of size of binary string, to store the powers of two.
• Iterate till size and for each i store 2i % K in poweroftwo[].
• Initialize variables, say rem = 0, to store the current remaining number till i.
• Iterate till size and for each i and if S[size – i -1]  is 1 then update rem equals rem + poweroftwo[i].
• Finally, return Yes if rem equals zero else return No.

Below is the implementation of the above approach:

## C++

 `// C++ program for above approach``#include ``using` `namespace` `std;` `// Function to check the binary number is``// divisible by K``string divisibleByk(string s, ``int` `n, ``int` `k)``{``    ``// Array poweroftwo will store pow(2, i)%k``    ``int` `poweroftwo[n];` `    ``// Initializing the first element in Array``    ``poweroftwo[0] = 1 % k;` `    ``for` `(``int` `i = 1; i < n; i++) {` `        ``// Storing every pow(2, i)%k value in``        ``// the array``        ``poweroftwo[i] = (poweroftwo[i - 1]``                         ``* (2 % k))``                        ``% k;``    ``}` `    ``// To store the remaining``    ``int` `rem = 0;` `    ``// Iterating till N``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// If current bit is 1``        ``if` `(s[n - i - 1] == ``'1'``) {` `            ``// Updating rem``            ``rem += (poweroftwo[i]);``            ``rem %= k;``        ``}``    ``}` `    ``// If completely divisible``    ``if` `(rem == 0) {``        ``return` `"Yes"``;``    ``}` `    ``// If not Completely divisible``    ``else``        ``return` `"No"``;``}` `// Driver Code``int` `main()``{``    ``// Given Input``    ``string s = ``"1010001"``;``    ``int` `k = 9;` `    ``// length of string s``    ``int` `n = s.length();` `    ``// Function Call``    ``cout << divisibleByk(s, n, k);``    ``return` `0;``}`

## Java

 `// Java program for above approach``class` `GFG``{``  ` `    ``// Function to check the binary number is``    ``// divisible by K``    ``public` `static` `String divisibleByk(String s, ``int` `n, ``int` `k) {``        ``// Array poweroftwo will store pow(2, i)%k``        ``int``[] poweroftwo = ``new` `int``[n];` `        ``// Initializing the first element in Array``        ``poweroftwo[``0``] = ``1` `% k;` `        ``for` `(``int` `i = ``1``; i < n; i++) {` `            ``// Storing every pow(2, i)%k value in``            ``// the array``            ``poweroftwo[i] = (poweroftwo[i - ``1``] * (``2` `% k)) % k;``        ``}` `        ``// To store the remaining``        ``int` `rem = ``0``;` `        ``// Iterating till N``        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``// If current bit is 1``            ``if` `(s.charAt(n - i - ``1``) == ``'1'``) {` `                ``// Updating rem``                ``rem += (poweroftwo[i]);``                ``rem %= k;``            ``}``        ``}` `        ``// If completely divisible``        ``if` `(rem == ``0``) {``            ``return` `"Yes"``;``        ``}` `        ``// If not Completely divisible``        ``else``            ``return` `"No"``;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{` `      ``// Given Input``        ``String s = ``"1010001"``;``        ``int` `k = ``9``;` `        ``// length of string s``        ``int` `n = s.length();` `        ``// Function Call``        ``System.out.println(divisibleByk(s, n, k));``    ``}` `}` `// This code is contributed by _saurabh_jaiswal,`

## Python3

 `# python 3 program for above approach` `# Function to check the binary number is``# divisible by K``def` `divisibleByk(s, n, k):``  ` `    ``# Array poweroftwo will store pow(2, i)%k``    ``poweroftwo ``=` `[``0` `for` `i ``in` `range``(n)]` `    ``# Initializing the first element in Array``    ``poweroftwo[``0``] ``=` `1` `%` `k` `    ``for` `i ``in` `range``(``1``,n,``1``):``        ``# Storing every pow(2, i)%k value in``        ``# the array``        ``poweroftwo[i] ``=` `(poweroftwo[i ``-` `1``] ``*` `(``2` `%` `k)) ``%` `k` `    ``# To store the remaining``    ``rem ``=` `0` `    ``# Iterating till N``    ``for` `i ``in` `range``(n):``      ` `        ``# If current bit is 1``        ``if` `(s[n ``-` `i ``-` `1``] ``=``=` `'1'``):` `            ``# Updating rem``            ``rem ``+``=` `(poweroftwo[i])``            ``rem ``%``=` `k` `    ``# If completely divisible``    ``if` `(rem ``=``=` `0``):``        ``return` `"Yes"` `    ``# If not Completely divisible``    ``else``:``        ``return` `"No"` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``# Given Input``    ``s ``=` `"1010001"``    ``k ``=` `9` `    ``# length of string s``    ``n ``=` `len``(s)` `    ``# Function Call``    ``print``(divisibleByk(s, n, k))``    ` `    ``# This code is contributed by SURENDRA_GANGWAR.`

## C#

 `// C# program for above approach``using` `System;``class` `GFG``{``  ` `    ``// Function to check the binary number is``    ``// divisible by K``    ``public` `static` `String divisibleByk(String s, ``int` `n, ``int` `k) {``        ``// Array poweroftwo will store pow(2, i)%k``        ``int``[] poweroftwo = ``new` `int``[n];` `        ``// Initializing the first element in Array``        ``poweroftwo[0] = 1 % k;` `        ``for` `(``int` `i = 1; i < n; i++) {` `            ``// Storing every pow(2, i)%k value in``            ``// the array``            ``poweroftwo[i] = (poweroftwo[i - 1] * (2 % k)) % k;``        ``}` `        ``// To store the remaining``        ``int` `rem = 0;` `        ``// Iterating till N``        ``for` `(``int` `i = 0; i < n; i++) {` `            ``// If current bit is 1``            ``if` `(s[n - i - 1] == ``'1'``) {` `                ``// Updating rem``                ``rem += (poweroftwo[i]);``                ``rem %= k;``            ``}``        ``}` `        ``// If completely divisible``        ``if` `(rem == 0) {``            ``return` `"Yes"``;``        ``}` `        ``// If not Completely divisible``        ``else``            ``return` `"No"``;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String []args)``    ``{` `      ``// Given Input``        ``String s = ``"1010001"``;``        ``int` `k = 9;` `        ``// length of string s``        ``int` `n = s.Length;` `        ``// Function Call``        ``Console.Write(divisibleByk(s, n, k));``    ``}` `}` `// This code is contributed by shivanisinghss2110`

## Javascript

 ``
Output
`Yes`

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

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