Open In App

Round to next smaller multiple of 8

Improve
Improve
Like Article
Like
Save
Share
Report

Given an unsigned integer x. Round it down to the next smaller multiple of 8 using bitwise operations only.
Examples: 
 

Input : 35
Output : 32

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

 

Solution 1: A naive approach to solve this problem using arithmetic operators is : 
Let x be the number then, 
x = x – (x % 8) 
This will round down x to the next smaller multiple of 8. But we are not allowed to use arithmetic operators.
Solution 2: An efficient approach to solve this problem using bitwise AND operation is: x = x & (-8) 
This will round down x to the next smaller multiple of 8. The idea is based on the fact that last three bits in a multiple of 8 must be 0,
Below is the implementation of above idea:
 

C++




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




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


Python3




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




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


Javascript




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


Output

32

Time Complexity: The time complexity of this approach is O(1) 
Auxiliary Space: The space complexity of this approach is O(1)

 Another Approach : Using shift operators 
To get the next smaller multiple of 8, we can divide the number by 8 and then multiply it by 8.
This can be accomplished using the shift operators as shown below:
 

C++




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


Java




import java.util.*;
 
class Main {
    static 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;
    }
 
    // Driver code
    public static void main(String[] args) {
        int x = 39;
        System.out.println(roundDown(x));
    }
}
 
// This code is contributed by vinayetbi1


Python3




# Python program to find next smaller
# multiple of 8.
def 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
x = 39
print(RoundDown(x))
 
# This code is contributed by phasing17.


C#




using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
// C# code implementation
 
class HelloWorld {
     
    public static 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;
    }
     
    static void Main() {
        int x = 39;
        Console.WriteLine(roundDown(x));
    }
}
 
// The code is contributed by Nidhi goel.


Javascript




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


Output

32

Time Complexity: O(1) 
Auxiliary Space:  O(1)



Last Updated : 14 Mar, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads