Open In App

Compute modulus division by a power-of-2-number

Compute n modulo d without division(/) and modulo(%) operators, where d is a power of 2 number.

```Input: 6 4
Output: 2
Explanation: As 6%4 = 2

Input: 12 8
Output: 4
Explanation: As 12%8 = 4

Input: 10 2
Output: 0
Explanation:As 10%2 = 0```

Let ith bit from right is set in d. For getting n modulus d, we just need to return 0 to i-1 (from right) bits of n as they are and other bits as 0.
For example if n = 6 (00..110) and d = 4(00..100). Last set bit in d is at position 3 (from right side). So we need to return last two bits of n as they are and other bits as 0, i.e., 00..010.
Now doing it is so easy, guess it….
Yes, you have guessing it right. See the below program.

C

 `#include` `// This function will return n % d.``// d must be one of: 1, 2, 4, 8, 16, 32, …``unsigned ``int` `getModulo(unsigned ``int` `n,``                       ``unsigned ``int` `d)``{``return` `( n & (d - 1) );``}        ` `// Driver Code``int` `main()``{``unsigned ``int` `n = 6;` `// d must be a power of 2``unsigned ``int` `d = 4;``printf``(``"%u modulo %u is %u"``, n, d, getModulo(n, d));` `getchar``();``return` `0;``}    `

C++

 `#include``using` `namespace` `std;``// This function will return n % d.``// d must be one of: 1, 2, 4, 8, 16, 32, …``unsigned ``int` `getModulo(unsigned ``int` `n,``                       ``unsigned ``int` `d)``{``  ``return` `( n & (d - 1) );``}        ` `// Driver Code``int` `main()``{``  ``unsigned ``int` `n = 6;` `  ``// d must be a power of 2``  ``unsigned ``int` `d = 4;``  ``cout<< n <<``" modulo "``<

Java

 `// Java code for Compute modulus division by``// a power-of-2-number``import` `java.io.*;``public` `class` `GFG {``    ` `    ``// This function will return n % d.``    ``// d must be one of: 1, 2, 4, 8, 16, 32,``    ``static` `int` `getModulo(``int` `n, ``int` `d)``    ``{``        ``return` `( n & (d-``1``) );``    ``}    ``    ` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``6``;``        ` `        ``/*d must be a power of 2*/``        ``int` `d = ``4``;``        ` `        ``System.out.println(n+``" modulo "` `+ d +``                    ``" is "` `+ getModulo(n, d));``    ``}``}` `// This code is contributed``// by Smitha Dinesh Semwal.`

Python3

 `# Python code to demonstrate``# modulus division by power of 2`  `# This function will``# return n % d.``# d must be one of:``# 1, 2, 4, 8, 16, 32, …``def` `getModulo(n, d):` `    ``return` `( n & (d``-``1``) )``         ` `# Driver program to``# test above function``n ``=` `6` `#d must be a power of 2``d ``=` `4``print``(n,``"modulo"``,d,``"is"``,``      ``getModulo(n, d))` `# This code is contributed by``# Smitha Dinesh Semwal`

Javascript

 ``

C#

 `// C# code for Compute modulus``// division by a power-of-2-number``using` `System;` `class` `GFG {``    ` `// This function will return n % d.``// d must be one of: 1, 2, 4, 8, 16, 32, …``static` `uint` `getModulo( ``uint` `n, ``uint` `d)``{``return` `( n & (d-1) );``}    ` `// Driver code``static` `public` `void` `Main ()``   ``{``    ``uint` `n = 6;``    ``uint` `d = 4; ``/*d must be a power of 2*/` `    ``Console.WriteLine( n + ``" modulo "` `+ d +``                ``" is "` `+ getModulo(n, d));``    ` `    ``}``}``// This code is contributed by vt_m.`

PHP

 ``

Output

`6 modulo 4 is 2`

Time Complexity: O(1), As we are doing single operation which takes constant time.
Auxiliary Space: O(1), As constant extra space is used.

Another Approach:

• Read in the values of n and d from the user.
• Subtract 1 from d to get a number with all bits set to 1 up to the position of the highest set bit in d. This is called the mask.
• Perform a bitwise AND of n and the mask to get the remainder. This will give us the last i bits of n where i is the position of the highest set bit in d.
• Output the result.

C++

 `#include ` `using` `namespace` `std;` `int` `main()``{` `    ``int` `n, d;` `    ``n = 6;``    ``d = 4;` `    ``int` `mask = d - 1; ``// mask is a number with all bits set``                      ``// to 1 up to the position of the``                      ``// highest set bit in d` `    ``int` `result = n & mask; ``// bitwise AND of n and mask``                           ``// gives the remainder` `    ``cout << result << endl;` `    ``return` `0;``}`

Java

 `import` `java.io.*;`  `public` `class` `Main {``    ``public` `static` `void` `main(String[] args) {``        ``int` `n, d;` `        ``n = ``6``;``        ``d = ``4``;` `        ``int` `mask = d - ``1``; ``// mask is a number with all bits set``                          ``// to 1 up to the position of the``                          ``// highest set bit in d` `        ``int` `result = n & mask; ``// bitwise AND of n and mask``                               ``// gives the remainder` `        ``System.out.println(result);``    ``}``}`

Javascript

 `let n, d;` `n = 6;``d = 4;` `let mask = d - 1; ``// mask is a number with all bits set``                  ``// to 1 up to the position of the``                  ``// highest set bit in d` `let result = n & mask; ``// bitwise AND of n and mask``                       ``// gives the remainder` `document.write(result);`

C#

 `using` `System;` `class` `Program``{``    ``static` `void` `Main(``string``[] args)``    ``{``        ``int` `n, d;` `        ``n = 6;``        ``d = 4;` `        ``int` `mask = d - 1; ``// mask is a number with all bits set``                          ``// to 1 up to the position of the``                          ``// highest set bit in d` `        ``int` `result = n & mask; ``// bitwise AND of n and mask``                               ``// gives the remainder` `        ``Console.WriteLine(result);` `        ``Console.ReadLine();``    ``}``}`

Python3

 `n ``=` `6``d ``=` `4` `mask ``=` `d ``-` `1` `result ``=` `n & mask` `print``(result)`

Output

`2`

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

References:
http://graphics.stanford.edu/~seander/bithacks.html#ModulusDivisionEasy
Please write comments if you find any bug in the above program/algorithm or other ways to solve the same problem.