# Write an Efficient Method to Check if a Number is Multiple of 3

• Difficulty Level : Medium
• Last Updated : 02 Aug, 2022

The very first solution that comes to our mind is the one that we learned in school. If the sum of digits in a number is a multiple of 3 then the number is a multiple of 3, e.g., for 612, the sum of digits is 9 so it’s a multiple of 3. But this solution is not efficient. You have to get all decimal digits one by one, add them and then check if the sum is a multiple of 3.

There is a pattern in the binary representation of a number that can be used to find if a number is a multiple of 3. If the difference between the count of odd set bits (Bits set at odd positions) and even set bits is a multiple of 3 then is the number.
Example: 23 (00..10111)
1) Get count of all set bits at odd positions (For 23 it’s 3).
2) Get count of all set bits at even positions (For 23 it’s 1).
3) If the difference between the above two counts is a multiple of 3 then the number is also a multiple of 3.
(For 23 it’s 2 so 23, is not a multiple of 3)
Take some more examples like 21, 15, etc…

```Algorithm: isMutlipleOf3(n)
1) Make n positive if n is negative.
2) If number is 0 then return 1
3) If number is 1 then return 0
4) Initialize: odd_count = 0, even_count = 0
5) Loop while n != 0
a) If rightmost bit is set then increment odd count.
b) Right-shift n by 1 bit
c) If rightmost bit is set then increment even count.
d) Right-shift n by 1 bit
6) return isMutlipleOf3(odd_count - even_count)```

Proof:

Let the binary representation of the number be: abcde.

In decimal form this number will be:

Every even power of 2 can be represented as 3n + 1, and every odd power of 2 can be represented as 3n – 1. For example:

`ans so on...`

Therefore, the decimal form becomes:

`[Tex](3n)(a+b+c+d+e) + (a - b + c - d + e) \\[/Tex](multiple of 3)`

To have this number divisible by 3, the term  should be divisible by 3.

Therefore for the number to be divisible by, the difference between the count of odd set bits (a + c + e) and even set bits (b + d) should be divisible by 3.

Time Complexity: O(logn)
Program:

## C++

 `// CPP program to check if n is a multiple of 3``#include ``using` `namespace` `std;` `/* Function to check if n is a multiple of 3*/``int` `isMultipleOf3(``int` `n)``{``    ``int` `odd_count = 0;``    ``int` `even_count = 0;` `    ``/* Make no positive if +n is multiple of 3``    ``then is -n. We are doing this to avoid``    ``stack overflow in recursion*/``    ``if` `(n < 0)``        ``n = -n;``    ``if` `(n == 0)``        ``return` `1;``    ``if` `(n == 1)``        ``return` `0;` `    ``while` `(n) {``        ``/* If odd bit is set then``        ``increment odd counter */``        ``if` `(n & 1)``            ``odd_count++;` `        ``/* If even bit is set then``        ``increment even counter */``        ``if` `(n & 2)``            ``even_count++;``        ``n = n >> 2;``    ``}` `    ``return` `isMultipleOf3(``abs``(odd_count - even_count));``}` `/* Program to test function isMultipleOf3 */``int` `main()``{``    ``int` `num = 24;``    ``if` `(isMultipleOf3(num))``        ``printf``(``"%d is multiple of 3"``, num);``    ``else``        ``printf``(``"%d is not a multiple of 3"``, num);``    ``return` `0;``}`

## Java

 `// Java program to check if``// n is a multiple of 3``import` `java.lang.*;``import` `java.util.*;` `class` `GFG {``    ``// Function to check if n``    ``// is a multiple of 3``    ``static` `int` `isMultipleOf3(``int` `n)``    ``{``        ``int` `odd_count = ``0``;``        ``int` `even_count = ``0``;` `        ``/* Make no positive if +n is multiple``    ``of 3 then is -n. We are doing this to``    ``avoid stack overflow in recursion*/``        ``if` `(n < ``0``)``            ``n = -n;``        ``if` `(n == ``0``)``            ``return` `1``;``        ``if` `(n == ``1``)``            ``return` `0``;` `        ``while` `(n != ``0``) {``            ``/* If odd bit is set then``        ``increment odd counter */``            ``if` `((n & ``1``) != ``0``)``                ``odd_count++;` `            ``/* If even bit is set then``        ``increment even counter */``            ``if` `((n & ``2``) != ``0``)``                ``even_count++;` `            ``n = n >> ``2``;``        ``}` `        ``return` `isMultipleOf3(Math.abs(odd_count - even_count));``    ``}` `    ``/* Program to test function isMultipleOf3 */``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `num = ``24``;` `        ``if` `(isMultipleOf3(num) != ``0``)``            ``System.out.println(num + ``" is multiple of 3"``);``        ``else``            ``System.out.println(num + ``" is not a multiple of 3"``);``    ``}``}` `// This code is contributed by Sahil_Bansall`

## Python3

 `# Python program to check if n is a multiple of 3` `# Function to check if n is a multiple of 3``def` `isMultipleOf3(n):` `    ``odd_count ``=` `0``    ``even_count ``=` `0` `    ``# Make no positive if + n is multiple of 3``    ``# then is -n. We are doing this to avoid``    ``# stack overflow in recursion``    ``if``(n < ``0``):``        ``n ``=` `-``n``    ``if``(n ``=``=` `0``):``        ``return` `1``    ``if``(n ``=``=` `1``):``        ``return` `0` `    ``while``(n):``        ` `        ``# If odd bit is set then``        ``# increment odd counter``        ``if``(n & ``1``):``            ``odd_count ``+``=` `1` `        ``# If even bit is set then``        ``# increment even counter``        ``if``(n & ``2``):``            ``even_count ``+``=` `1``        ``n ``=` `n >> ``2` `    ``return` `isMultipleOf3(``abs``(odd_count ``-` `even_count))` `# Program to test function isMultipleOf3``num ``=` `24``if` `(isMultipleOf3(num)):``    ``print``(num, ``'is multiple of 3'``)``else``:``    ``print``(num, ``'is not a multiple of 3'``)` `# This code is contributed by Danish Raza`

## C#

 `// C# program to check if``// n is a multiple of 3``using` `System;` `class` `GFG {` `    ``// Function to check if n``    ``// is a multiple of 3``    ``static` `int` `isMultipleOf3(``int` `n)``    ``{``        ``int` `odd_count = 0, even_count = 0;` `        ``/* Make no positive if +n is multiple``        ``of 3 then is -n. We are doing this to``        ``avoid stack overflow in recursion*/``        ``if` `(n < 0)``            ``n = -n;``        ``if` `(n == 0)``            ``return` `1;``        ``if` `(n == 1)``            ``return` `0;` `        ``while` `(n != 0) {` `            ``/* If odd bit is set then``            ``increment odd counter */``            ``if` `((n & 1) != 0)``                ``odd_count++;` `            ``/* If even bit is set then``            ``increment even counter */``            ``if` `((n & 2) != 0)``                ``even_count++;` `            ``n = n >> 2;``        ``}` `        ``return` `isMultipleOf3(Math.Abs(odd_count - even_count));``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``int` `num = 24;` `        ``if` `(isMultipleOf3(num) != 0)``            ``Console.Write(num + ``" is multiple of 3"``);``        ``else``            ``Console.Write(num + ``" is not a multiple of 3"``);``    ``}``}` `// This code is contributed by Sam007`

## PHP

 `> 2;``    ``}` `    ``return` `isMultipleOf3(``abs``(``\$odd_count` `-``                             ``\$even_count``));``}` `// Driver Code``\$num` `= 24;``if` `(isMultipleOf3(``\$num``))``    ``echo` `\$num``, ``"is multiple of 3"``;``else``    ``echo` `\$num``, ``"is not a multiple of 3"``;``    ` `// This code is contributed by vt_m.``?>`

## Javascript

 ``

Output

`24 is multiple of 3`

Efficient Method:

Use Dynamic Programming (Top-Down Approach Using Memoization)

## C++

 `// CPP program to check if n is a multiple of 3``#include ``using` `namespace` `std;` `int` `static` `dp[1001];` `/* Function to check if n is a multiple of 3*/``int` `isMultipleOf3(``int` `n)``{``    ``int` `odd_count = 0;``    ``int` `even_count = 0;``    ` `    ``// Base Cases``    ``if` `(n < 0)``        ``n = -n;``        ` `    ``if` `(n == 0)``        ``return` `1;``        ` `    ``if` `(n == 1)``        ``return` `0;``    ` `    ``// If a value is already present``    ``// in dp, return it``    ``if``(dp[n] != -1)``        ``return` `dp[n];``    ` `    ``while` `(n) {``        ``/* If odd bit is set then``        ``increment odd counter */``        ``if` `(n & 1)``            ``odd_count++;` `        ``/* If even bit is set then``        ``increment even counter */``        ``if` `(n & 2)``            ``even_count++;``        ``n = n >> 2;``    ``}` `    ``dp[n] = isMultipleOf3(``abs``(odd_count - even_count));``    ` `    ``// return dp``    ``return` `dp[n];``}` `/* Program to test function isMultipleOf3 */``int` `main()``{``    ``int` `num = 24;``    ` `    ``memset``(dp, -1, ``sizeof``(dp));``    ` `    ``if` `(isMultipleOf3(num))``        ``printf``(``"%d is multiple of 3"``, num);``    ``else``        ``printf``(``"%d is not a multiple of 3"``, num);``    ``return` `0;``}`

## C

 `// C program to check if n is a multiple of 3``#include ``#include` `int` `static` `dp[1001];` `/* Function to check if n is a multiple of 3*/``int` `isMultipleOf3(``int` `n)``{``    ``int` `odd_count = 0;``    ``int` `even_count = 0;``    ` `    ``// Base Cases``    ``if` `(n < 0)``        ``n = -n;``        ` `    ``if` `(n == 0)``        ``return` `1;``        ` `    ``if` `(n == 1)``        ``return` `0;``    ` `    ``// If a value is already present``    ``// in dp, return it``    ``if``(dp[n] != -1)``        ``return` `dp[n];``    ` `    ``while` `(n) {``        ``/* If odd bit is set then``        ``increment odd counter */``        ``if` `(n & 1)``            ``odd_count++;` `        ``/* If even bit is set then``        ``increment even counter */``        ``if` `(n & 2)``            ``even_count++;``        ``n = n >> 2;``    ``}``  ` `  ``int` `abs` `= (odd_count - even_count);``  ``if``(``abs``<0)``  ``{``    ``abs``= -1*``abs``;``  ``}` `    ``dp[n] = isMultipleOf3(``abs``);``    ` `    ``// return dp``    ``return` `dp[n];``}` `/* Program to test function isMultipleOf3 */``int` `main()``{``    ``int` `num = 24;``    ` `    ``memset``(dp, -1, ``sizeof``(dp));``    ` `    ``if` `(isMultipleOf3(num))``        ``printf``(``"%d is multiple of 3"``, num);``    ``else``        ``printf``(``"%d is not a multiple of 3"``, num);``    ``return` `0;``}` `// This code is contributed by akashish_.`

## Java

 `// JAVA program to check if n is a multiple of 3` `import` `java.util.*;` `class` `GFG{` ` ``static` `int` `[]dp ;` `/* Function to check if n is a multiple of 3*/``static` `int` `isMultipleOf3(``int` `n)``{``    ``int` `odd_count = ``0``;``    ``int` `even_count = ``0``;``    ` `    ``// Base Cases``    ``if` `(n < ``0``)``        ``n = -n;``        ` `    ``if` `(n == ``0``)``        ``return` `1``;``        ` `    ``if` `(n == ``1``)``    ``return` `0``;``    ` `    ``// If a value is already present``    ``// in dp, return it``    ``if``(dp[n] != -``1``)``        ``return` `dp[n];``    ` `    ``while` `(n > ``0``) {``        ``/* If odd bit is set then``        ``increment odd counter */``        ``if` `((n & ``1``) != ``0``)``            ``odd_count++;`` ` `        ``/* If even bit is set then``        ``increment even counter */``        ``if` `((n & ``2``) != ``0``)``            ``even_count++;``        ``n = n >> ``2``;``    ``}``    ``dp[n] = isMultipleOf3(Math.abs(odd_count - even_count));``    ` `    ``// return dp``    ``return` `dp[n];``}` `/* Program to test function isMultipleOf3 */``public` `static` `void` `main(String[] args)``{``    ``int` `num = ``24``;``    ``dp = ``new` `int``[``1001``];``    ``Arrays.fill(dp, -``1``);``    ` `    ``if` `(isMultipleOf3(num) == ``1``)``        ``System.out.printf(``"%d is multiple of 3"``, num);``    ``else``        ``System.out.printf(``"%d is not a multiple of 3"``, num);``}``}` `// This codeiscontributed by Rajput-Ji`

## Python3

 `# Python program to check if n is a multiple of 3``dp ``=` `[``-``1` `for` `i ``in` `range``(``1001``)];` `''' Function to check if n is a multiple of 3 '''``def` `isMultipleOf3(n):``    ``odd_count ``=` `0``;``    ``even_count ``=` `0``;` `    ``# Base Cases``    ``if` `(n < ``0``):``        ``n ``=` `-``n;` `    ``if` `(n ``=``=` `0``):``        ``return` `1``;` `    ``if` `(n ``=``=` `1``):``        ``return` `0``;` `    ``# If a value is already present``    ``# in dp, return it``    ``if` `(dp[n] !``=` `-``1``):``        ``return` `dp[n];` `    ``while` `(n > ``0``):``        ``'''``         ``* If odd bit is set then increment odd counter``         ``'''``        ``if` `((n & ``1``) !``=` `0``):``            ``odd_count``+``=``1``;` `        ``'''``         ``* If even bit is set then increment even counter``         ``'''``        ``if` `((n & ``2``) !``=` `0``):``            ``even_count``+``=``1``;``        ``n ``=` `n >> ``2``;``    ` `    ``dp[n] ``=` `isMultipleOf3(``abs``(odd_count ``-` `even_count));` `    ``# return dp``    ``return` `dp[n];`  `''' Program to test function isMultipleOf3 '''``if` `__name__ ``=``=` `'__main__'``:``    ``num ``=` `24``;` `    ``if` `(isMultipleOf3(num) ``=``=` `1``):``        ``print``(num,``"is multiple of 3"``);``    ``else``:``        ``print``(num,``" is not a multiple of 3"``);` `# This code is contributed by Rajput-Ji`

## C#

 `// C# program to check if``// n is a multiple of 3``using` `System;` `class` `GFG {``    ` `static` `int` `[]dp = ``new` `int``[1001];`` ` `/* Function to check if n is a multiple of 3*/``static` `int` `isMultipleOf3(``int` `n)``{``    ``int` `odd_count = 0;``    ``int` `even_count = 0;``     ` `    ``// Base Cases``    ``if` `(n < 0)``        ``n = -n;``         ` `    ``if` `(n == 0)``        ``return` `1;``         ` `    ``if` `(n == 1)``        ``return` `0;``     ` `    ``// If a value is already present``    ``// in dp, return it``    ``if``(dp[n] != -1)``        ``return` `dp[n];``     ` `    ``while` `(n > 0) {``        ``/* If odd bit is set then``        ``increment odd counter */``        ``if` `((n & 1) != 0)``            ``odd_count++;`` ` `        ``/* If even bit is set then``        ``increment even counter */``        ``if` `((n & 2) != 0)``            ``even_count++;``        ``n = n >> 2;``    ``}`` ` `    ``dp[n] = isMultipleOf3(Math.Abs(odd_count - even_count));``     ` `    ``// return dp``    ``return` `dp[n];``}` `    ``// Driver Code``public` `static` `void` `Main()``{``   ``int` `num = 24;``     ` `    ``for``(``int` `i = 0; i < 1001; i++) {``        ``dp[i] = -1;``    ``}``     ` `    ``if` `(isMultipleOf3(num) == 1)``        ``Console.Write(num + ``" is multiple of 3"``);``    ``else``        ``Console.Write(num + ``" is not a multiple of 3"``);` `}``}` `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`24 is multiple of 3`

Time Complexity: O(n)

Auxiliary Space: O(n)

Method: Checking given number is multiple of 3 or not using modulo division.

## C++

 `// C++ program to check if given number is multiple of 3 or``// not using modulo division` `#include ``using` `namespace` `std;` `int` `main()``{``    ``// input number``    ``int` `num = 24;``    ``cout << num;``    ``// checking if the given number if multiple of 3 or not``    ``// using modulo division operator if the output of num%3``    ``// is equal to 0 then it is considered as multiple of 3``    ``// otherwise not a multiple of 3``    ``if` `(num % 3 == 0) {``        ``cout << ``" is multiple of 3"``;``    ``}``    ``else` `{``        ``cout << ``" is not multiple of 3"``;``    ``}``    ``return` `0;``}` `// this code is contributed by gangarajula laxmi`

## Java

 `/*package whatever //do not write package name here */` `// Java code``// To check whether the given number is divisible by 3 or not``import` `java.io.*;``import` `java.util.*;`` ` `class` `GFG``{``  ` `  ``public` `static` `void` `main(String[] args)``  ``{``    ``//input``   ``int`  `num = ``24``;``    ``System.out.println(num);``    ` `    ``/// checking if the given number if multiple of 3 or not``    ``// using modulo division operator if the output of num%3``    ``// is equal to 0 then it is considered as multiple of 3``    ``// otherwise not a multiple of 3``    ``if` `((n) % ``3` `== ``0``)``    ``{``        ``System.out.println(``" is multiple of 3"``);``    ``}``    ``else``    ``{``        ``System.out.println(``" is not multiple of 3"``);``    ``}``   ``}``}` `// This code is contributed by satwik4409.`

## Python3

 `# Python3 program to check if given number is multiple of 3 or``# not using modulo division` `# input number``num ``=` `24``print``(num,end``=``"")` `# checking if the given number if multiple of 3 or not``# using modulo division operator if the output of num%3``# is equal to 0 then it is considered as multiple of 3``# otherwise not a multiple of 3``if` `(num ``%` `3` `is` `0``):``  ``print``(``" is multiple of 3"``)``else``:``  ``print``( ``" is not multiple of 3"``)` `# This code is contributed by akashish__`

## C#

 `// C# program to check if given number is multiple of 3 or``// not using modulo division``using` `System;` `public` `class` `GFG {` `  ``static` `public` `void` `Main()``  ``{` `    ``// input number``    ``int` `num = 24;` `    ``// checking if the given number if multiple of 3 or``    ``// not using modulo division operator if the output``    ``// of num%3 is equal to 0 then it is considered as``    ``// multiple of 3 otherwise not a multiple of 3``    ``if` `(num % 3 == 0) {``      ``Console.WriteLine(num+``" is multiple of 3"``);``    ``}``    ``else` `{``      ``Console.WriteLine(num+``" is not multiple of 3"``);``    ``}``  ``}``}` `// This code is contributed by laxmigangarajula03`

## Javascript

 ``

Output

`24 is multiple of 3`

Related Articles:
Check divisibility in a binary stream
DFA based division
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

My Personal Notes arrow_drop_up