Comprobar si un número es divisible por 23 o no

Dado un número, la tarea es verificar rápidamente si el número es divisible por 23 o no.
Ejemplos: 
 

Input : x  = 46
Output : Yes

Input : 47
Output : No

Una solución al problema es extraer el último dígito y sumar 7 veces el último dígito al número restante y repetir este proceso hasta obtener un número de dos dígitos. Si el número de dos dígitos obtenido es divisible por 23, entonces el número dado es divisible por 23.
Enfoque:
 

• Extraiga el último dígito del número/número truncado cada vez
• Añadir 7*(último dígito del número anterior) al número truncado
• Repita los tres pasos anteriores todo el tiempo que sea necesario.

Ilustración: 
 

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

Prueba matemática: 
Sea  cualquier número tal que  =100a+10b+c. 
Ahora suponga que  es divisible por 23. Entonces 
0 (mod 23) 
100a+10b+c 0 (mod 23) 
10(10a+b)+c 0 (mod 23) 
10 +c 0 (mod 23)
Ahora que hemos separado el último dígito del número, tenemos que encontrar una manera de usarlo. 
Haz el coeficiente de  1. 
En otras palabras, tenemos que encontrar un entero tal que n tal que 10n 1 mod 23. 
Se puede observar que el n más pequeño que satisface esta propiedad es 7 como 70 1 mod 23. 
Ahora podemos multiplicar la ecuación original 10 +c 0 (mod 23) 
por 7 y simplificarlo: 
70 +7c 0 (mod 23) 
+7c 0 (mod 23) 
Hemos encontrado que si  0 (mod 23) entonces, 
+7c 0 (mod 23). 
En otras palabras, para verificar si un número de 3 dígitos es divisible por 23, 
podemos eliminar el último dígito, multiplicarlo por 7 
y luego restarlo del resto de los dos dígitos. 
 

// 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 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 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# 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 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
?>

<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>

Yes

Tenga en cuenta que el programa anterior puede no tener mucho sentido, ya que simplemente podría hacer n % 23 para verificar la divisibilidad. La idea de este programa es validar el concepto. Además, este podría ser un enfoque eficiente si el número de entrada es grande y se proporciona como una string.