Comprobar si un número es múltiplo de 9 usando operadores bit a bit

Dado un número n, escribe una función que devuelva verdadero si n es divisible por 9, de lo contrario, falso. La forma más sencilla de verificar la divisibilidad de n entre 9 es hacer n%9. 
Otro método es sumar los dígitos de n. Si la suma de dígitos es múltiplo de 9, entonces n es múltiplo de 9. 
Los métodos anteriores no son métodos basados ​​en operadores bit a bit y requieren el uso de % y /. 
Los operadores bit a bit son generalmente más rápidos que los operadores de módulo y división. El siguiente es un método basado en un operador bit a bit para verificar la divisibilidad por 9. 
 

// C++ program to check if a number
// is multiple of 9 using bitwise operators
#include <bits/stdc++.h>
using namespace std;
 
// Bitwise operator based function to check divisibility by 9
bool isDivBy9(int n)
{
    // Base cases
    if (n == 0 || n == 9)
        return true;
    if (n < 9)
        return false;
 
    // If n is greater than 9, then recur for [floor(n/9) - n%8]
    return isDivBy9((int)(n >> 3) - (int)(n & 7));
}
 
// Driver program to test above function
int main()
{
    // Let us print all multiples of 9 from 0 to 100
    // using above method
    for (int i = 0; i < 100; i++)
        if (isDivBy9(i))
            cout << i << " ";
    return 0;
}

// Java program to check if a number
// is multiple of 9 using bitwise operators
import java.lang.*;
 
class GFG {
 
    // Bitwise operator based function
    // to check divisibility by 9
    static boolean isDivBy9(int n)
    {
 
        // Base cases
        if (n == 0 || n == 9)
            return true;
        if (n < 9)
            return false;
 
        // If n is greater than 9, then
        // recur for [floor(n/9) - n%8]
        return isDivBy9((int)(n >> 3) - (int)(n & 7));
    }
 
    // Driver code
    public static void main(String arg[])
    {
 
        // Let us print all multiples of 9 from
        // 0 to 100 using above method
        for (int i = 0; i < 100; i++)
            if (isDivBy9(i))
                System.out.print(i + " ");
    }
}
 
// This code is contributed by Anant Agarwal.

# Bitwise operator based
# function to check divisibility by 9
 
def isDivBy9(n):
 
    # Base cases
    if (n == 0 or n == 9):
        return True
    if (n < 9):
        return False
  
    # If n is greater than 9,
    # then recur for [floor(n / 9) - n % 8]
    return isDivBy9((int)(n>>3) - (int)(n&7))
 
# Driver code
 
# Let us print all multiples
# of 9 from 0 to 100
# using above method
for i in range(100):
    if (isDivBy9(i)):
        print(i, " ", end ="")
 
# This code is contributed
# by Anant Agarwal.

// C# program to check if a number
// is multiple of 9 using bitwise operators
using System;
 
class GFG {
 
    // Bitwise operator based function
    // to check divisibility by 9
    static bool isDivBy9(int n)
    {
        // Base cases
        if (n == 0 || n == 9)
            return true;
        if (n < 9)
            return false;
 
        // If n is greater than 9, then
        // recur for [floor(n/9) - n%8]
        return isDivBy9((int)(n >> 3) - (int)(n & 7));
    }
 
    // Driver code
    public static void Main()
    {
        // Let us print all multiples of 9 from
        // 0 to 100 using above method
        for (int i = 0; i < 100; i++)
            if (isDivBy9(i))
                Console.Write(i + " ");
    }
}
 
// This code is contributed by nitin mittal.

<?php
// PHP program to check if a number
// is multiple of 9 using bitwise
// operators
 
// Bitwise operator based function
// to check divisibility by 9
function isDivBy9($n)
{
     
    // Base cases
    if ($n == 0 || $n == 9)
        return true;
    if ($n < 9)
        return false;
 
    // If n is greater than 9,
    // then recur for [floor(n/9) -
    // n%8]
    return isDivBy9(($n >> 3) -
                    ($n & 7));
}
 
    // Driver Code
    // Let us print all multiples
    // of 9 from 0 to 100
    // using above method
    for ($i = 0; $i < 100; $i++)
        if (isDivBy9($i))
            echo $i ," ";
             
// This code is contributed by nitin mittal
?>

<script>
// javascript program to check if a number
// is multiple of 9 using bitwise operators
 
// Bitwise operator based function
// to check divisibility by 9
function isDivBy9(n)
{
 
    // Base cases
    if (n == 0 || n == 9)
        return true;
    if (n < 9)
        return false;
 
    // If n is greater than 9, then
    // recur for [floor(n/9) - n%8]
    return isDivBy9(parseInt(n >> 3) - parseInt(n & 7));
}
 
// Driver code
 
    // Let us print all multiples of 9 from
// 0 to 100 using above method
for (i = 0; i < 100; i++)
    if (isDivBy9(i))
        document.write(i + " ");
 
// This code is contributed by Princi Singh
</script>

Producción: 

0 9 18 27 36 45 54 63 72 81 90 99

Complejidad de tiempo: O (log n)

Espacio auxiliar: O(logn)
¿Cómo funciona esto?  
n/9 se puede escribir en términos de n/8 usando la siguiente fórmula simple. 

n/9 = n/8 - n/72

Como necesitamos usar operadores bit a bit, obtenemos el valor de floor(n/8) usando n>>3 y obtenemos el valor de n%8 usando n&7 . Necesitamos escribir la expresión anterior en términos de floor(n/8) y n%8 . 
n/8 es igual a “piso(n/8) + (n%8)/8” . Escribamos la expresión anterior en términos de piso (n/8) y n%8

n/9 = floor(n/8) + (n%8)/8 - [floor(n/8) + (n%8)/8]/9
n/9 = floor(n/8) - [floor(n/8) - 9(n%8)/8 + (n%8)/8]/9
n/9 = floor(n/8) - [floor(n/8) - n%8]/9

De la ecuación anterior, n es un múltiplo de 9 solo si la expresión piso (n/8) – [piso (n/8) – n%8]/9 es un número entero. Esta expresión solo puede ser un número entero si la subexpresión [piso(n/8) – n%8]/9 es un número entero. La subexpresión solo puede ser un número entero si [floor(n/8) – n%8] es un múltiplo de 9 . Entonces, el problema se reduce a un valor más pequeño que se puede escribir en términos de operadores bit a bit.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.