Open in App
Not now

# Check divisibility by 7

• Difficulty Level : Easy
• Last Updated : 20 Mar, 2023

Given a number N, the task is to check if it is divisible by 7 or not.
Note: You are not allowed to use the modulo operator, floating point arithmetic is also not allowed.

Naive approach: A simple method is repeated subtraction. Following is another interesting method.
Divisibility by 7 can be checked by a recursive method. A number of the form 10a + b is divisible by 7 if and only if a – 2b is divisible by 7. In other words, subtract twice the last digit from the number formed by the remaining digits. Continue to do this until a small number.

Example: the number 371: 37 – (2Ã—1) = 37 – 2 = 35; 3 – (2 Ã— 5) = 3 – 10 = -7; thus, since -7 is divisible by 7, 371 is divisible by 7.
Following is the implementation of the above method

## C++

 `// A Program to check whether a number is divisible by 7 ` `#include ` `using` `namespace` `std; `   `int` `isDivisibleBy7( ``int` `num ) ` `{ ` `    ``// If number is negative, make it positive ` `    ``if``( num < 0 ) ` `        ``return` `isDivisibleBy7( -num ); `   `    ``// Base cases ` `    ``if``( num == 0 || num == 7 ) ` `        ``return` `1; ` `    ``if``( num < 10 ) ` `        ``return` `0; `   `    ``// Recur for ( num / 10 - 2 * num % 10 ) ` `    ``return` `isDivisibleBy7( num / 10 - 2 *` `            ``( num - num / 10 * 10 ) ); ` `} `   `// Driver code ` `int` `main() ` `{ ` `    ``int` `num = 616; ` `    ``if``( isDivisibleBy7(num ) ) ` `        ``cout << ``"Divisible"` `; ` `    ``else` `        ``cout << ``"Not Divisible"` `; ` `    ``return` `0; ` `} `   `// This code is contributed by rathbhupendra`

## C

 `// A Program to check whether a number is divisible by 7` `#include `   `int` `isDivisibleBy7( ``int` `num )` `{` `    ``// If number is negative, make it positive` `    ``if``( num < 0 )` `        ``return` `isDivisibleBy7( -num );`   `    ``// Base cases` `    ``if``( num == 0 || num == 7 )` `        ``return` `1;` `    ``if``( num < 10 )` `        ``return` `0;`   `    ``// Recur for ( num / 10 - 2 * num % 10 ) ` `    ``return` `isDivisibleBy7( num / 10 - 2 * ( num - num / 10 * 10 ) );` `}`   `// Driver program to test above function` `int` `main()` `{` `    ``int` `num = 616;` `    ``if``( isDivisibleBy7(num ) )` `        ``printf``( ``"Divisible"` `);` `    ``else` `        ``printf``( ``"Not Divisible"` `);` `    ``return` `0;` `}`

## Java

 `// Java program to check whether a number is divisible by 7` `import` `java.io.*;`   `class` `GFG ` `{` `    ``// Function to check whether a number is divisible by 7` `    ``static` `boolean` `isDivisibleBy7(``int` `num)` `    ``{` `        ``// If number is negative, make it positive` `        ``if``( num < ``0` `)` `            ``return` `isDivisibleBy7( -num );` ` `  `        ``// Base cases` `        ``if``( num == ``0` `|| num == ``7` `)` `            ``return` `true``;` `        ``if``( num < ``10` `)` `            ``return` `false``;` ` `  `        ``// Recur for ( num / 10 - 2 * num % 10 ) ` `        ``return` `isDivisibleBy7( num / ``10` `- ``2` `* ( num - num / ``10` `* ``10` `) );` `    ``}` `    `  `    ``// Driver program` `    ``public` `static` `void` `main (String[] args) ` `    ``{` `        ``int` `num = ``616``;` `        ``if``(isDivisibleBy7(num))` `            ``System.out.println(``"Divisible"``);` `        ``else` `            ``System.out.println(``"Not Divisible"``);` `    ``}` `}`   `// Contributed by Pramod Kumar`

## Python3

 `# Python program to check whether a number is divisible by 7`   `# Function to check whether a number is divisible by 7` `def` `isDivisibleBy7(num) :` `    `  `    ``# If number is negative, make it positive` `    ``if` `num < ``0` `:` `        ``return` `isDivisibleBy7( ``-``num )`   `    ``# Base cases` `    ``if``( num ``=``=` `0` `or` `num ``=``=` `7` `) :` `        ``return` `True` `    `  `    ``if``( num < ``10` `) :` `        ``return` `False` `        `  `    ``# Recur for ( num / 10 - 2 * num % 10 ) ` `    ``return` `isDivisibleBy7( num ``/``/` `10` `-` `2` `*` `( num ``-` `num ``/``/` `10` `*` `10` `) )` `    `  `# Driver program` `num ``=` `616` `if``(isDivisibleBy7(num)) :` `    ``print` `(``"Divisible"``)` `else` `:` `    ``print` `(``"Not Divisible"``)`   `# This code is contributed by Nikita Tiwari`

## C#

 `// C# program to check whether a ` `// number is divisible by 7` `using` `System;`   `class` `GFG {` `    `  `    ``// Function to check whether a` `    ``// number is divisible by 7` `    ``static` `bool` `isDivisibleBy7(``int` `num)` `    ``{` `        `  `        ``// If number is negative, ` `        ``// make it positive` `        ``if``( num < 0 )` `            ``return` `isDivisibleBy7(-num);`   `        ``// Base cases` `        ``if``( num == 0 || num == 7 )` `            ``return` `true``;` `        ``if``( num < 10 )` `            ``return` `false``;`   `        ``// Recur for ( num / 10 - 2 * num % 10 ) ` `        ``return` `isDivisibleBy7(num / 10 - 2 * ` `                             ``( num - num / 10 * 10 ));` `    ``}` `    `  `    ``// Driver Code` `    ``public` `static` `void` `Main () ` `    ``{` `        ``int` `num = 616;` `        ``if``(isDivisibleBy7(num))` `            ``Console.Write(``"Divisible"``);` `        ``else` `            ``Console.Write(``"Not Divisible"``);` `    ``}` `}`   `// This code is contributed by Nitin Mittal.`

## PHP

 `=0 )` `        ``echo``(``"Divisible"``);` `    ``else` `        ``echo``(``"Not Divisible"``);` `    `  `// This code is contributed by vt_m.` `?>`

## Javascript

 ``

Output

`Divisible`

Time Complexity: O(log n)
Auxiliary Space: O(log n)

How does this work? Let ‘b’ be the last digit of a number ‘n’ and let ‘a’ be the number we get when we split off ‘b’.
The representation of the number may also be multiplied by any number relatively prime to the divisor without changing its divisibility. After observing that 7 divides 21, we can perform the following:

` 10.a + b `

after multiplying by 2, this becomes

` 20.a + 2.b `

and then

` 21.a - a + 2.b `

Eliminating the multiple of 21 gives

` -a + 2b`

and multiplying by -1 gives

` a - 2b`

Method: To check given number is divisible by 7 or not by using the modulo division operator “%”.

## C++

 `#include ` `using` `namespace` `std;` `int` `main()` `{`   `    ``// To check whether the given number is divisible by` `    ``// 7 or not` `    ``int` `n = 371;`   `    ``// finding given number is divisible by 7 or not` `    ``if` `(n % 7 == 0) {` `        ``cout << (``"divisible"``);` `    ``}` `    ``else` `{` `        ``cout << (``"Not divisible"``);` `    ``}` `}`   `// This code is contributed by garg28harsh.`

## Java

 `// Java code for the above approach` `import` `java.io.*;`   `class` `GFG {` `  ``public` `static` `void` `main(String[] args)` `  ``{`   `    ``// To check whether the given number is divisible by` `    ``// 7 or not`   `    ``int` `n = ``371``;`   `    ``// finding given number is divisible by 7 or not` `    ``if` `((``int``)n % ``7` `== ``0``) {` `      ``System.out.print(``"divisible"``);` `    ``}` `    ``else` `{` `      ``System.out.print(``"Not divisible"``);` `    ``}` `  ``}` `}`   `// This code is contributed by lokesh`

## Python3

 `# Python code ` `# To check whether the given number is divisible by 7 or not`   `#input ` `n``=``371` `# the above input can also be given as n=input() -> taking input from user` `# finding given number is divisible by 7 or not` `if` `int``(n)``%``7``=``=``0``:` `  ``print``(``"divisible"``) ` `else``: ` `  ``print``(``"Not divisible"``) ` `  `  `  ``# this code is contributed by gangarajula laxmi`

## C#

 `// C# code for the above approach` `using` `System;` `public` `class` `GFG {`   `  ``static` `public` `void` `Main()` `  ``{`   `    ``// To check whether the given number is divisible by` `    ``// 7 or not`   `    ``int` `n = 371;`   `    ``// finding given number is divisible by 7 or not` `    ``if` `((``int``)n % 7 == 0) {` `      ``Console.Write(``"divisible"``);` `    ``}` `    ``else` `{` `      ``Console.Write(``"Not divisible"``);` `    ``}` `  ``}` `}`   `// This code is contributed by lokesh`

## Javascript

 ``

## PHP

 ``

Output

`divisible`

Time complexity: O(1) because it is performing constant operations
Auxiliary space: O(1)

Method: Checking the divisibility using the arithmetic(/) operator

## C++

 `#include ` `using` `namespace` `std;`   `int` `main() {` `  ``int` `n = 616;` `  ``int` `quo = n/7;` `  ``if``((quo*7) == n){` `    ``cout << ``"Divisible"``;` `  ``}` `  ``else``{` `    ``cout << ``"Not Divisible"``;` `  ``}` `  ``return` `0;` `}`

## Java

 `//Java code for the above approach`   `import` `java.io.*;`   `class` `Gfg {` `  ``//Driver code` `    ``public` `static` `void` `main(String[] args) {` `        ``int` `n = ``616``;` `        ``int` `quo = n/``7``;` `        ``if``((quo*``7``) == n){` `            ``System.out.println(``"Divisible"``);` `        ``}` `        ``else``{` `            ``System.out.println(``"Not Divisible"``);` `        ``}` `    ``}` `}`

## Python3

 `n ``=` `616` `quo ``=` `int``(n``/``7``)` `if` `quo``*``7` `=``=` `n:` `  ``print``(``"Divisible"``)` `else``:` `  ``print``(``"Not Divisible"``)`

## C#

 `// C# code for the above approach:` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `Gfg` `{`   `  ``// Driver code` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{` `    ``int` `n = 616;` `    ``int` `quo = n/7;` `    ``if``((quo*7) == n){` `      ``Console.WriteLine(``"Divisible"``);` `    ``}` `    ``else``{` `      ``Console.WriteLine(``"Not Divisible"``);` `    ``}` `  ``}` `}`   `// This code is contributed by ritaagarwal.`

## Javascript

 `let n = 616;` `let quo = Math.floor(n/7);` `if``((quo*7) == n){` `  ``console.log(``"Divisible"``);` `}` `else``{` `  ``console.log(``"Not Divisible"``);` `}`   `// This code is contributed by poojaagarwal2.`

Output

`Divisible`

Time complexity : O(1)

Space complexity : O(1)

### Method: alternating digit sum

Here are the steps for the “alternating digit sum” method to check the divisibility of a number by 7:

1. Initialize a variable multiplier to 1 and a variable result to 0.
2. Starting from the least significant digit of the number, multiply each digit by the multiplier variable and add the result to result.
3. If multiplier is 1, set multiplier to 2. Otherwise, set multiplier to 1.
4. Repeat steps 2-3 until all digits have been processed.
5. If the absolute value of result is divisible by 7, then the original number is divisible by 7. Otherwise, it is not.

## Python3

 `def` `is_divisible_by_7(num):` `    ``result ``=` `0` `    ``multiplier ``=` `1` `    ``while` `num > ``0``:` `        ``digit ``=` `num ``%` `10` `        ``result ``+``=` `digit ``*` `multiplier` `        ``num ``/``/``=` `10` `        ``multiplier ``=` `3` `-` `multiplier  ``# switch between 1 and 2` `    ``return` `abs``(result) ``%` `7` `=``=` `0`     `# Example usages` `print``(is_divisible_by_7(``434``))  ``# Output: True` `print``(is_divisible_by_7(``123456789``))  ``# Output: False` `print``(is_divisible_by_7(``-``343``))  ``# Output: True`

## Javascript

 `// Function to check if a number is divisible by 7` `function` `is_divisible_by_7(num) {` `    ``let result = 0;` `    ``let multiplier = 1;` `    `  `    ``// Iterate through the digits of the number` `    ``while` `(num > 0) {` `        ``const digit = num % 10;` `        ``result += digit * multiplier;` `    `  `        ``// Update the number and multiplier` `        ``num = Math.floor(num / 10);` `        ``multiplier = 3 - multiplier; ``// switch between 1 and 2` `    ``}` `    `  `    ``// Check if the absolute value of result is divisible by 7` `    ``return` `Math.abs(result) % 7 === 0;` `}`   `// Example usages` `console.log(is_divisible_by_7(434)); ``// Output: true` `console.log(is_divisible_by_7(123456789)); ``// Output: false` `console.log(is_divisible_by_7(-343)); ``// Output: true`

Output

```True
False
True```

The time complexity of the is_divisible_by_7 function is O(log n)

The auxiliary space of the function is O(1)

There are other interesting methods to check divisibility by 7 and other numbers. See the following Wiki page for details.
References:
http://en.wikipedia.org/wiki/Divisibility_rule