Redondear al siguiente múltiplo menor de 8

Dado un entero sin signo x. Redondee hacia abajo al siguiente múltiplo más pequeño de 8 usando solo operaciones bit a bit.
Ejemplos: 
 

Input : 35
Output : 32

Input : 40
Output : 40 
As 40 is already a multiple of 8. So, no 
modification is done.

Solución 1: Un enfoque ingenuo para resolver este problema usando operadores aritméticos es: 
Sea x el número entonces, 
x = x – (x % 8) 
Esto redondeará x al siguiente múltiplo menor de 8. Pero no se nos permite utilizar operadores aritméticos.
Solución 2: Un enfoque eficiente para resolver este problema usando la operación AND bit a bit es: x = x & (-8) 
Esto redondeará x al siguiente múltiplo más pequeño de 8. La idea se basa en el hecho de que los últimos tres bits en un múltiplo de 8 debe ser 0, a
continuación se muestra la implementación de la idea anterior:
 

// CPP program to find next smaller
// multiple of 8.
#include <bits/stdc++.h>
using namespace std;
 
int RoundDown(int& a)
{
    return a & (-8);
}
 
int main()
{
    int x = 39;
    cout << RoundDown(x);
    return 0;
}

//Java program to find next smaller
// multiple of 8.
 
import java.io.*;
 
class GFG {
static int RoundDown(int a)
{
    return a & (-8);
}
 
    public static void main (String[] args) {
 
    int x = 39;
    System.out.println (RoundDown(x));
    }
}
//This Code is Contributed by ajit

# Python 3 program to find next
# smaller multiple of 8.
 
def RoundDown(a):
    return a & (-8)
 
# Driver Code
if __name__ == '__main__':
    x = 39
    print(RoundDown(x))
 
# This code is contributed
# by Surendra_Gangwar

// C# program to find next smaller
// multiple of 8.
using System;
 
class GFG
{
static int RoundDown(int a)
{
    return a & (-8);
}
 
public static void Main()
{
    int x = 39;
    Console.Write(RoundDown(x));
}
}
 
// This code is contributed
// by Akanksha Rai

<?php
// PHP program to find next smaller
// multiple of 8.
 
function RoundDown($a)
{
    return ($a & (-8));
}
 
// Driver Code
$x = 39;
echo RoundDown($x);
 
// This code is contributed by jit_t
?>

<script>
    // Javascript program to find next smaller multiple of 8.
     
    function RoundDown(a)
    {
        return a & (-8);
    }
     
    let x = 39;
    document.write(RoundDown(x));
 
</script>

32

Complejidad de tiempo: La complejidad de tiempo de este enfoque es O(1) 
Espacio auxiliar: La complejidad de espacio de este enfoque es O(1)

 Otro enfoque : usar operadores de cambio 
Para obtener el siguiente múltiplo más pequeño de 8, podemos dividir el número por 8 y luego multiplicarlo por 8.
Esto se puede lograr usando los operadores de cambio como se muestra a continuación:
 

// CPP program to find next smaller
// multiple of 8.
#include <bits/stdc++.h>
using namespace std;
  
int RoundDown(int& a)
{
    //Using >> 3 divides the number by 2 power 3
    //or 8, and << 3 reverses it, by multiplying
    //the result by 8
    return (a >> 3) << 3;
}
 
int main()
{
    int x = 39;
    cout << RoundDown(x) << endl;
    return 0;
}
 
 
//This code is contributed by phasing17

// JavaScript program to find next smaller
// multiple of 8.
function RoundDown(a)
{
    // Using >> 3 divides the number by 2 power 3
    // or 8, and << 3 reverses it, by multiplying
    // the result by 8
    return (a >> 3) << 3;
}
 
// Driver Code
let x = 39;
console.log(RoundDown(x));
 
 
//This code is contributed by phasing17

32

Complejidad temporal : O(1) 
Espacio auxiliar:  O(1)