Open In App
Related Articles

Check if a number is divisible by 23 or not

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Given a number, the task is to quickly check if the number is divisible by 23 or not.
Examples: 
 

Input : x  = 46
Output : Yes

Input : 47
Output : No


 


A solution to the problem is to extract the last digit and add 7 times of last digit to remaining number and repeat this process until a two digit number is obtained. If the obtained two digit number is divisible by 23, then the given number is divisible by 23.
Approach:
 

  • Extract the last digit of the number/truncated number every time
  • Add 7*(last digit of the previous number) to the truncated number
  • Repeat the above three steps as long as necessary.


Illustration: 
 

 
17043-->1704+7*3 
= 1725-->172+7*5
= 207 which is 9*23, 
so 17043 is also divisible by 23.


 

Mathematical Proof : 
Let \overline{a b c}   be any number such that \overline{a b c}   =100a+10b+c . 
Now assume that \overline{a b c}   is divisible by 23. Then 
\overline{a b c}\equiv   0 (mod 23) 
100a+10b+c\equiv   0 (mod 23) 
10(10a+b)+c\equiv   0 (mod 23) 
10\overline{a b}   +c\equiv   0 (mod 23)
Now that we have separated the last digit from the number, we have to find a way to use it. 
Make the coefficient of \overline{a b}   1. 
In other words, we have to find an integer such that n such that 10n\equiv   1 mod 23. 
It can be observed that the smallest n which satisfies this property is 7 as 70\equiv   1 mod 23. 
Now we can multiply the original equation 10\overline{a b}   +c\equiv   0 (mod 23) 
by 7 and simplify it: 
70\overline{a b}   +7c\equiv   0 (mod 23) 
\overline{a b}   +7c\equiv   0 (mod 23) 
We have found out that if \overline{a b c}\equiv   0 (mod 23) then, 
\overline{a b}   +7c\equiv   0 (mod 23). 
In other words, to check if a 3-digit number is divisible by 23, 
we can just remove the last digit, multiply it by 7, 
and then subtract it from the rest of the two digits. 
 


 

C++

// CPP program to validate above logic
#include <iostream>
using namespace std;
 
// Function to check if the number is
// divisible by 23 or not
bool isDivisible(long long int n)
{
 
    // While there are at least 3 digits
    while (n / 100)
    {
        int d = n % 10; // Extracting the last digit
        n /= 10; // Truncating the number
 
        // Adding seven times the last
        // digit to the remaining number
        n += d * 7;
    }
 
    return (n % 23 == 0);
}
 
int main()
{
    long long int n = 1191216;
    if (isDivisible(n))
        cout << "Yes" << endl;
    else
        cout << "No" << endl;
    return 0;
}

                    

Java

// Java program to validate above logic
class GFG
{
     
// Function to check if the
// number is divisible by
// 23 or not
static boolean isDivisible(long n)
{
 
    // While there are at
    // least 3 digits
    while (n / 100 != 0)
    {
        // Extracting the last digit
        long d = n % 10;
         
        n /= 10; // Truncating the number
 
        // Adding seven times the last
        // digit to the remaining number
        n += d * 7;
    }
 
    return (n % 23 == 0);
}
 
// Driver Code
public static void main(String[] args)
{
    long n = 1191216;
    if(isDivisible(n))
        System.out.println("Yes");
    else
        System.out.println("No");
}
}
 
// This code is contributed by mits

                    

Python 3

# Python 3 program to validate above logic
 
# Function to check if the number is
# divisible by 23 or not
def isDivisible(n) :
 
    # While there are at least 3 digits
    while n // 100 :
 
        # Extracting the last
        d = n % 10
 
        # Truncating the number
        n //= 10
 
        # Adding seven times the last 
        # digit to the remaining number
        n += d * 7
 
    return (n % 23 == 0)
 
# Driver Code
if __name__ == "__main__" :
 
    n = 1191216
 
    # function calling
    if (isDivisible(n)) :
        print("Yes")
 
    else :
        print("No")
 
# This code is contributed by ANKITRAI1

                    

C#

// C# program to validate
// above logic
class GFG
{
     
// Function to check if the
// number is divisible by
// 23 or not
static bool isDivisible(long n)
{
 
    // While there are at
    // least 3 digits
    while (n / 100 != 0)
    {
        // Extracting the last digit
        long d = n % 10;
         
        n /= 10; // Truncating the number
 
        // Adding seven times the last
        // digit to the remaining number
        n += d * 7;
    }
 
    return (n % 23 == 0);
}
 
// Driver Code
public static void Main()
{
    long n = 1191216;
    if(isDivisible(n))
        System.Console.WriteLine("Yes");
    else
        System.Console.WriteLine("No");
}
}
 
// This code is contributed by mits

                    

PHP

<?php
// PHP program to validate above logic
 
// Function to check if the number
// is divisible by 23 or not
function isDivisible($n)
{
 
    // While there are at
    // least 3 digits
    while (intval($n / 100))
    {
        $n = intval($n);
        $d = $n % 10; // Extracting the last digit
        $n /= 10; // Truncating the number
 
        // Adding seven times the last
        // digit to the remaining number
        $n += $d * 7;
    }
 
    return ($n % 23 == 0);
}
 
$n = 1191216;
if (isDivisible($n))
echo "Yes" . "\n";
else
echo "No" . "\n";
 
// This code is contributed
// by ChitraNayal
?>

                    

Javascript

<script>
 
// JavaScript program to validate above logic
 
// Function to check if the
// number is divisible by
// 23 or not
function isDivisible(n)
{
    // While there are at
    // least 3 digits
    while (Math.floor(n / 100) != 0)
    {
        // Extracting the last digit
        let d = n % 10;
           
        n = Math.floor(n/10); // Truncating the number
   
        // Adding seven times the last
        // digit to the remaining number
        n += d * 7;
    }
   
    return (n % 23 == 0);
}
 
// Driver Code
let n = 1191216;
if(isDivisible(n))
    document.write("Yes");
else
    document.write("No");
     
 
// This code is contributed by rag2127
 
</script>

                    

Output: 
Yes

 

Time Complexity: O(log10N)

Auxiliary Space: O(1)

Note that the above program may not make a lot of sense as could simply do n % 23 to check for divisibility. The idea of this program is to validate the concept. Also, this might be an efficient approach if input number is large and given as string.
 


Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!


Last Updated : 31 Jul, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads
Complete Tutorials