Open In App

Set all odd bits of a number

Last Updated : 26 Apr, 2023
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

Given a number, the task is to set all odd bits of a number. Positions of bits are counted from LSB (least significant bit) to MSB (Most significant bit). Position of LSB is considered as 1.

Examples : 

Input : 20
Output : 21
Explanation : Binary representation of 20
is 10100. Setting all odd
bits make the number 10101 which is binary
representation of 21.

Input : 10
Output : 15
Recommended Practice
Set all odd bits
Try It!

Method 1 (Using OR) 
1. First generate a number that contains odd position bits. 
2. Take OR with the original number. Note that 1 | 1 = 1 and 1 | 0 = 1.

Let’s understand this approach with below code.  

C++ 
// CPP code Set all odd bits 
// of a number
#include <iostream>
using namespace std;

// set all odd bit
int oddbitsetnumber(int n)
{
    int count = 0;

    // res for store 010101.. number
    int res = 0;

    // generate number form of 010101.....till
    // temp size
    for (int temp = n; temp > 0; temp >>= 1) {

        // if bit is odd, then generate
        // number and or with res
        if (count % 2 == 0)
            res |= (1 << count);

        count++;
    }

    return (n | res);
}

// Driver code
int main()
{
    int n = 10;
    cout << oddbitsetnumber(n);
    return 0;
}
Java 
// Java code to Set all odd 
// bits of a number

class GFG 
{

    // set all odd bit
    static int oddbitsetnumber(int n)
    {
        int count = 0;

        // res for store 010101.. number
        int res = 0;

        // generate number form of 
        // 010101.....till temp size
        for (int temp = n; temp > 0; temp >>= 1) 
        {

            // if bit is odd, then generate
            // number and or with res
            if (count % 2 == 0)
                res |= (1 << count);

            count++;
        }

        return (n | res);
    }

    // Driver code
    public static void main(String[] args)
    {
        int n = 10;
        System.out.println(oddbitsetnumber(n));
    }
}

// This code is contributed 
// by prerna saini
Python3 
''' Python3 code Set all odd bits 
   of a number'''
   
# set all odd bit
def oddbitsetnumber(n):
    count = 0
    # res for store 010101.. number
    res = 0

    # generate number form of 010101.....till
    # temp size
    temp = n
    while temp > 0:

        # if bit is odd, then generate
        # number and or with res
        if count % 2 == 0:
            res |= (1 << count)

        count += 1
        temp >>= 1

    return (n | res)

n = 10
print (oddbitsetnumber(n))

#This code is contributed by Shreyanshi Arun.
C# 
// C# code to Set all odd 
// bits of a number
using System;

class GFG
{
    static int oddbitsetnumber(int n)
    {
        int count = 0;

        // res for store 010101.. number
        int res = 0;

        // generate number form of 
        // 010101.....till temp size
        for (int temp = n; temp > 0; 
                           temp >>= 1) 
        {

            // if bit is odd, then 
            // generate number and 
            // or with res
            if (count % 2 == 0)
                res |= (1 << count);

            count++;
        }

        return (n | res);
    }
    
    // Driver Code
    static public void Main ()
    {
        int n = 10;
        Console.WriteLine(oddbitsetnumber(n));
    }
}

// This code is contributed 
// by prerna ajit
PHP 
<?php
// php code Set all odd 
// bits  of a number

// set all odd bit
function oddbitsetnumber($n)
{
    $count = 0;

    // res for store 010101..
    // number
    $res = 0;

    // generate number form of 
    // 010101... till temp size
    for ($temp = $n; $temp > 0; $temp >>= 1) 
    {

        // if bit is odd, then generate
        // number and or with res
        if ($count % 2 == 0)
            $res |= (1 << $count);

        $count++;
    }

    return ($n | $res);
}

    // Driver code
    $n = 10;
    echo oddbitsetnumber($n);

// This code is contributed by mits 
?>
JavaScript 
<script>

// JavaScript Program to Set all odd
// bits of a number

    // set all odd bit
    function oddbitsetnumber(n)
    {
        let count = 0;
 
        // res for store 010101.. number
        let res = 0;
 
        // generate number form of
        // 010101.....till temp size
        for (let temp = n; temp > 0; temp >>= 1)
        {
 
            // if bit is odd, then generate
            // number and or with res
            if (count % 2 == 0)
                res |= (1 << count);
 
            count++;
        }
        return (n | res);
    }
  
// Driver Code
        let n = 10;
        document.write(oddbitsetnumber(n));
       
       // This code is contributed by chinmoy1997pal.
</script>

Output
15


Method 2 (A O(1) solution for 32 bit numbers) 

C++ 
// Efficient CPP program to set all 
// odd bits number
#include <iostream>
using namespace std;

// return MSB set number
int getmsb(int n)
{
    // set all bits including MSB.
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;

    // return MSB
    return (n + 1) >> 1;
}

// Returns a number of same size (MSB at
// same position) as n and all odd bits
// set.
int getevenbits(int n)
{
    n = getmsb(n);

    // generate odd bits like 010101..
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;

    // if bits is even then shift by 1
    if ((n&1) == 0)
        n = n >> 1;
    
    // return odd set bits number
    return n;  
}

// set all odd bits here
int setalloddbits(int n)
{    
    // take OR with odd set bits number
    return n | getevenbits(n);    
}

// Driver code
int main()
{
    int n = 10;
    cout << setalloddbits(n);
    return 0; 
}
Java 
// Efficient Java program to set
// all odd bits number
class GFG {

    // return MSB set number
    static int getmsb(int n)
    {
        // set all bits including MSB.
        n |= n >> 1;
        n |= n >> 2;
        n |= n >> 4;
        n |= n >> 8;
        n |= n >> 16;

        // return MSB
        return (n + 1) >> 1;
    }

    // Returns a number of same 
    // size (MSB at same position) 
    // as n and all odd bits set.
    static int getevenbits(int n)
    {
        n = getmsb(n);

        // generate odd bits 
        // like 010101..
        n |= n >> 2;
        n |= n >> 4;
        n |= n >> 8;
        n |= n >> 16;

        // if bits is even 
        // then shift by 1
        if ((n & 1) == 0)
            n = n >> 1;

        // return odd set bits number
        return n;
    }

    // set all odd bits here
    static int setalloddbits(int n)
    {
        // take OR with odd 
        // set bits number
        return n | getevenbits(n);
    }

    // Driver code
    public static void main(String[] args)
    {
        int n = 10;
        System.out.println(setalloddbits(n));
    }
}

// This code is contributed 
// by prerna saini
Python3 
# Efficient python3 program to  
# set all odd bits number
import math

# return MSB set number
def getmsb( n):

    # set all bits including MSB.
    n |= n >> 1
    n |= n >> 2
    n |= n >> 4
    n |= n >> 8
    n |= n >> 16

    # return MSB
    return (n + 1) >> 1


# Returns a number of same
# size (MSB at same position) 
# as n and all odd bits set.
def getevenbits(n):

    n = getmsb(n)

    # generate odd bits 
    # like 010101..
    n |= n >> 2
    n |= n >> 4
    n |= n >> 8
    n |= n >> 16

    # if bits is even 
    # then shift by 1
    if ((n & 1) == 0):
        n = n >> 1
    
    # return odd set bits number
    return n


# set all odd bits here
def setalloddbits( n):

    # take OR with odd 
    # set bits number
    return n | getevenbits(n)


# Driver Program 
n = 10
print(setalloddbits(n))
    

# This code is contributed 
# by Gitanjali.
C# 
// Efficient C# program to 
// set all odd bits number
using System;

class GFG
{
    
    // return MSB set number
    static int getmsb(int n)
    {
        // set all bits
        // including MSB.
        n |= n >> 1;
        n |= n >> 2;
        n |= n >> 4;
        n |= n >> 8;
        n |= n >> 16;

        // return MSB
        return (n + 1) >> 1;
    }
    
    // Returns a number of same 
    // size (MSB at same position) 
    // as n and all odd bits set.
    static int getevenbits(int n)
    {
        n = getmsb(n);

        // generate odd bits 
        // like 010101..
        n |= n >> 2;
        n |= n >> 4;
        n |= n >> 8;
        n |= n >> 16;

        // if bits is even 
        // then shift by 1
        if ((n & 1) == 0)
            n = n >> 1;

        // return odd 
        // set bits number
        return n;
    }

    // set all odd bits here
    static int setalloddbits(int n)
    {
        // take OR with odd 
        // set bits number
        return n | getevenbits(n);
    }

    // Driver Code
    static public void Main ()
    {
        int n = 10;
        Console.WriteLine(setalloddbits(n));
    }
}

// This code is contributed ajit
PHP 
<?php
// Efficient php program to 
// set all  odd bits number

// return MSB set number
function getmsb($n)
{
    
    // set all bits
    // including MSB.
    $n |= $n >> 1;
    $n |= $n >> 2;
    $n |= $n >> 4;
    $n |= $n >> 8;
    $n |= $n >> 16;

    // return MSB
    return ($n + 1) >> 1;
}

// Returns a number of
// same size (MSB at
// same position) as n 
// and all odd bits set
function getevenbits($n)
{
    $n = getmsb($n);

    // generate odd bits 
    // like 010101..
    $n |= $n >> 2;
    $n |= $n >> 4;
    $n |= $n >> 8;
    $n |= $n >> 16;

    // if bits is even 
    // then shift by 1
    if (($n&1) == 0)
        $n = $n >> 1;
    
    // return odd set
    // bits number
    return $n; 
}

// set all odd bits here
function setalloddbits($n)
{ 
    
    // take OR with odd 
    // set bits number
    return $n | getevenbits($n); 
}

    // Driver code
    $n = 10;
    echo setalloddbits($n);

// This code is contributed by mits 
?>
JavaScript 
// Efficient Javascript program to
// set all odd bits number

// Return MSB set number
function getmsb(n)
{
    
    // Set all bits
    // including MSB.
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;

    // Return MSB
    return (n + 1) >> 1;
}
 
// Returns a number of same
// size (MSB at same position)
// as n and all odd bits set.
function getevenbits(n)
{
    n = getmsb(n);

    // Generate odd bits
    // like 010101..
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;

    // If bits is even
    // then shift by 1
    if ((n & 1) == 0)
        n = n >> 1;

    // Return odd
    // set bits number
    return n;
}

// Set all odd bits here
function setalloddbits(n)
{
    
    // Take OR with odd
    // set bits number
    return n | getevenbits(n);
}

// Driver Code
let n = 10;
console.log(setalloddbits(n));

// This code is contributed by decode2207

Output
15

Another approach:

O(1) approach which supports even long long (64-bit).

C++ 
#include <iostream>
using namespace std;

long long int setAllOddBits(long long int n) {
        // code here
        long long mask; 
          //find required num such that it
          //is of form 000.....1010
          if(__builtin_clz(n)%2==0){
            mask=0x5555555555555555>>(__builtin_clzll(n));
        }else{
            mask=0xAAAAAAAAAAAAAAAA>>(__builtin_clzll(n));
        }
        // return toggled number
        return n|mask;
    }

// Driver code
int main()
{
    int n = 10;
    cout << setAllOddBits(n);
    return 0;
}
Java 
// Java equivalent code for the given C++ code
// with the same comments

public class Main {
    public static long setAllOddBits(long n)
    {
        // find required num such that it is of form
        // 000.....1010
        long mask;
        if (Integer.numberOfLeadingZeros((int)n) % 2 == 0) {
            mask = 0x5555555555555555L
                   >>> Long.numberOfLeadingZeros(n);
        }
        else {
            mask = 0xAAAAAAAAAAAAAAAAL
                   >>> Long.numberOfLeadingZeros(n);
        } // return toggled number
        return n | mask;
    }

    public static void main(String[] args)
    {
        int n = 10;
        System.out.println(setAllOddBits(n));
    }
}
Python3 
# Python 3 implementation
def setAllOddBits(n):

    # find required num such that it is of form
    # 000.....1010
    if (bin(n).count('1') % 2 == 0):
        mask = 0x5555555555555555 >> (64 - len(bin(n)) + 2)
    else:
        mask = 0xAAAAAAAAAAAAAAAA >> (64 - len(bin(n)) + 2)

    # return toggled number
    return n | mask

# Driver code
n = 10
print(setAllOddBits(n))

# This code is contributed by phasing17.
C# 
using System;

public class Program {
    public static long SetAllOddBits(long n)
    {
        ulong un = (ulong)n;
        ulong mask;
        // find required num such that it
        // is of form 000.....1010
        if (CountLeadingZeros(un) % 2 == 0) {
            mask = 0x5555555555555555UL
                   >> CountLeadingZeros(un);
        }
        else {
            mask = 0xAAAAAAAAAAAAAAAAL
                   >> CountLeadingZeros(un);
        }
        // return toggled number
        return (long)(un | mask);
    }

    public static int CountLeadingZeros(ulong x)
    {
        int count = 0;
        while (x != 0) {
            x >>= 1;
            count++;
        }
        return 64 - count;
    }
    // Driver code
    public static void Main()
    {
        int n = 10;
        Console.WriteLine(SetAllOddBits(n));
    }
}
JavaScript 
// Javascript code addition 

function setAllOddBits(n) {
    // find required num such that it is of form
    // 000.....1010
    let x = 17;
    if (n.toString(2).split('1').length % 2 === 0) {
        mask = 0x5555555555555555 >> (64 - n.toString(2).length + 2);
    } else {
        mask = 0xAAAAAAAAAAAAAAAA >> (64 - n.toString(2).length + 2);
    }

    // return toggled number
    return n | mask + x;
}

let n = 10;
console.log(setAllOddBits(n));

// The code is contributed by Nidhi goel.

Output
15

Time complexity: O(1)

Space complexity: O(1)

Another Approach:

To set a bit, we can take OR of 1 and that bit (as 1 | 1 = 1, and 1 | 0 = 1). Therefore, to set all odd bits of an n bit number, we need to use a bit mask which is an n bit binary number with all odd bits set. This mask can be generated in 1 step using the formula of sum of a geometric progression, as an n bit number ...0101 is equal to 20 + 22 + 24 + .... 2 (n - 1 - !(n % 1)) .

C++ 
#include <bits/stdc++.h>
using namespace std;

// function to set all the odd bits
long long int setAllOddBits(long long int n)
{
    // calculating number of bits using log
    int numOfBits = 1 + (int)log2(n);
    // calculating the max power of GP series
    int m = (numOfBits + (numOfBits % 2)) / 2;
    // calculating mask using GP sum
    // which is a(r ^ n - 1) / (r - 1)
    // where a = 1, r = 4, n = m
    int mask = (pow(4, m) - 1) / 3;
    // setting all odd bits using mask | n
    return mask | n;
}

// Driver code
int main()
{
    int n = 10;
    // function call
    cout << setAllOddBits(n);
    return 0;
}

// this code is contributed by phasing17
Java 
// Java code to implement the approach

class GFG {
    // function to set all the odd bits
    static int setAllOddBits(int n)
    {
        // calculating number of bits using log
        int numOfBits
            = 1 + (int)(Math.log(n) / Math.log(2));

        // calculating the max power of GP series
        int m = (numOfBits + (numOfBits % 2)) / 2;

        // calculating mask using GP sum
        // which is a(r ^ n - 1) / (r - 1)
        // where a = 1, r = 4, n = m
        int mask = (int)(Math.pow(4, m) - 1) / 3;

        // setting all odd bits using mask | n
        return mask | n;
    }

    // Driver code
    public static void main(String[] args)
    {
        int n = 10;

        // function call
        System.out.println(setAllOddBits(n));
    }
}

// this code is contributed by phasing17
Python3 
# Python program to implement the approach

import math

# function to set all the odd bits
def setAllOddBits(n):

    # calculating number of bits using log
    numOfBits = 1 + math.floor(math.log2(n))

    # calculating the max power of GP series
    m = math.floor((numOfBits + (numOfBits % 2)) / 2)

    # calculating mask using GP sum
    # which is a(r ^ n - 1) / (r - 1)
    # where a = 1, r = 4, n = m
    mask = math.floor((math.pow(4, m) - 1) / 3)

    # setting all odd bits using mask | n
    return mask | n


# Driver code
n = 10

# function call
print(setAllOddBits(n))
C# 
using System;

public class Program
{
    // function to set all the odd bits
    static long setAllOddBits(long n)
    {
        // calculating number of bits using log
        int numOfBits = 1 + (int)Math.Log(n, 2);
        // calculating the max power of GP series
        int m = (numOfBits + (numOfBits % 2)) / 2;
        // calculating mask using GP sum
        // which is a(r ^ n - 1) / (r - 1)
        // where a = 1, r = 4, n = m
        int mask = (int)(Math.Pow(4, m) - 1) / 3;
        // setting all odd bits using mask | n
        return mask | n;
    }

    // Driver code
    public static void Main()
    {
        int n = 10;
        // function call
        Console.WriteLine(setAllOddBits(n));
    }
}
JavaScript 
//JavaScript program to implement the approach


// function to set all the odd bits
function setAllOddBits(n)
{
    
    // calculating number of bits using log
    let numOfBits = 1 + Math.floor(Math.log2(n));
    
    // calculating the max power of GP series
    let m = Math.floor((numOfBits + (numOfBits % 2)) / 2);
    
    // calculating mask using GP sum
    // which is a(r ^ n - 1) / (r - 1)
    // where a = 1, r = 4, n = m
    let mask = Math.floor((Math.pow(4, m) - 1) / 3);
    
    // setting all odd bits using mask | n
    return mask | n;
}


// Driver code
let n = 10;

// function call
console.log(setAllOddBits(n));



// this code is contributed by phasing17

Output
15

Time complexity: O(1)

Space complexity: O(1)


Next Article
Set all odd bits of a number

D
devanshuagarwal
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox