Open In App

Set all even bits of a number

Last Updated : 21 Nov, 2022
Summarize
Comments
Improve
Suggest changes
Share
Like Article
Like
Report

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

Examples : 

Input : 20 
Output : 30
Binary representation of 20 is
10100. After setting
even bits, we get 11110

Input : 10
Output : 10

Method 1:

  1. First, generate a number that contains even position bits. 
  2. Take OR with the original number. Note that 1 | 1 = 1 and 1 | 0 = 1.

Let’s understand this approach with the below code.

C++ 
// Simple CPP program to set all even
// bits of a number
#include <iostream>
using namespace std;

// Sets even bits of n and returns 
// modified number.
int evenbitsetnumber(int n)
{
    // Generate 101010...10 number and
    // store in res.
    int count = 0, res = 0;
    for (int temp = n; temp > 0; temp >>= 1) {

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

        count++;
    }

    // return OR number
    return (n | res);
}

int main()
{
    int n = 10;
    cout << evenbitsetnumber(n);
    return 0;
}
Java 
// Simple Java program to set all even
// bits of a number
class GFG 
{
    // Sets even bits of n and returns 
    // modified number.
    static int evenbitsetnumber(int n)
    {
        // Generate 101010...10 number and
        // store in res.
        int count = 0, res = 0;
        for (int temp = n; temp > 0; temp >>= 1) {
           
            // if bit is even then generate
            // number and or with res
            if (count % 2 == 1)
            res |= (1 << count);

        count++;
        }
        
        // return OR number
        return (n | res);
        
    }
    
    // Driver code
    public static void main(String[] args)
    {
        int n = 4;
         System.out.println(evenbitsetnumber(n));
    }
}

// This code is contributed 
// by  prerna saini.
Python3 
# Simple Python program to set all even
# bits of a number

# Sets even bits of n and returns 
# modified number.
def evenbitsetnumber(n):

    # Generate 101010...10 number and
    # store in res.
    count = 0
    res = 0
    temp = n
    while(temp > 0):

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

        count+=1
        temp >>= 1
        
    # return OR number
    return (n | res)

n = 10
print(evenbitsetnumber(n))

# This code is contributed
# by Smitha Dinesh Semwal
C# 
// Simple C# program to set 
// all even bits of a number
using System;

class GFG 
{
    // Sets even bits of n and 
    // returns modified number.
    static int evenbitsetnumber(int n) {
    
        // Generate 101010...10 number
        //  and store in res.
        int count = 0, res = 0;
        for (int temp = n; temp > 0; temp >>= 1) {
            
            // if bit is even then generate
            // number and or with res
            if (count % 2 == 1)
            res |= (1 << count);

        count++;
        }
        
        // return OR number
        return (n | res);
        
    }
    
    // Driver code
    public static void Main()
    {
        int n = 4;
        Console.WriteLine(evenbitsetnumber(n));
    }
}

// This code is contributed by vt_m.
PHP 
<?php
// Simple php program to set 
// all even bits of a number

// Sets even bits of n and 
// returns  modified number.
function evenbitsetnumber($n)
{
    
    // Generate 101010...10 number 
    // and store in res.
    $count = 0;
    $res = 0;
    for ($temp = $n; $temp > 0; $temp >>= 1) 
    {

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

        $count++;
    }

    // return OR number
    return ($n | $res);
}

    //Driver Code
    $n = 10;
    echo evenbitsetnumber($n);

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

// JavaScript program to set all even
// bits of a number

// Sets even bits of n and returns 
// modified number.
function evenbitsetnumber(n)
{
    
    // Generate 101010...10 number and
    // store in res.
    let count = 0, res = 0;
    for(let temp = n; temp > 0; temp >>= 1)
    {
        
        // If bit is even then generate
        // number and or with res
        if (count % 2 == 1)
            res |= (1 << count);
            
        count++;
    }
    
    // Return OR number
    return (n | res);
}

// Driver Code
let n = 10;

document.write(evenbitsetnumber(n));

// This code is contributed by avijitmondal1998

</script>

Output
10

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

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

// return msb set number
int getmsb(int n)
{

    // set all bits
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;

    // return msb
    // increment n by 1
    // and shift by 1
    return (n + 1) >> 1;
}

// return even set number
int getevenbits(int n)
{

    // get msb here
    n = getmsb(n);

    // generate even bits like 101010..
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;

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

    // return even set bits number
    return n;
}

// set all even bits here
int setallevenbits(int n)
{
    // take or with even set bits number
    return n | getevenbits(n);
}

int main()
{
    int n = 10;
    cout << setallevenbits(n);
    return 0;
}
Java 
// Efficient Java program to 
// set all even bits of a number
import java.io.*;

class GFG 
{
    
// return msb set number
static int getmsb(int n)
{

    // set all bits
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;

    // return msb
    // increment n by 1
    // and shift by 1
    return (n + 1) >> 1;
}

// return even set number
static int getevenbits(int n)
{

    // get msb here
    n = getmsb(n);

    // generate even 
    // bits like 101010..
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;

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

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

// set all even bits here
static int setallevenbits(int n)
{
    // take or with even
    // set bits number
    return n | getevenbits(n);
}

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

// This code is contributed by ajit
Python3 
# Efficient Python 3
# program to set all even
# bits of a number

# return msb set number
def getmsb(n):

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

    # return msb
    # increment n by 1
    # and shift by 1
    return (n + 1) >> 1


# return even set number
def getevenbits(n):
  
    # get msb here
    n = getmsb(n)

    # generate even bits like 101010..
    n |= n >> 2 
    n |= n >> 4 
    n |= n >> 8 
    n |= n >> 16 

    # if bits is odd then shift by 1
    if (n & 1):
        n = n >> 1 

    # return even set bits number
    return n 
 

# set all even bits here
def setallevenbits(n):
    
    # take or with even set bits number
    return n | getevenbits(n) 
 
n = 10 
print(setallevenbits(n)) 

# This code is contributed by
# Smitha Dinesh Semwal
C# 
// Efficient C# program to 
// set all even bits of a number
using System;

class GFG
{
    
// return msb set number
static int getmsb(int n)
{

    // set all bits
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;

    // return msb
    // increment n by 1
    // and shift by 1
    return (n + 1) >> 1;
}

// return even set number
static int getevenbits(int n)
{

    // get msb here
    n = getmsb(n);

    // generate even 
    // bits like 101010..
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;

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

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

// set all even bits here
static int setallevenbits(int n)
{
    // take or with even
    // set bits number
    return n | getevenbits(n);
}

// Driver Code
public static void Main ()
{
    int n = 10;

    Console.WriteLine(setallevenbits(n));
}
}

// This code is contributed by aj_36
PHP 
<?php
// Efficient php program to set 
// all even bits of a number

// return msb set number
function getmsb($n)
{

    // set all bits
    $n |= $n >> 1;
    $n |= $n >> 2;
    $n |= $n >> 4;
    $n |= $n >> 8;
    $n |= $n >> 16;

    // return msb
    // increment n by 1
    // and shift by 1
    return ($n + 1) >> 1;
}

// return even set number
function getevenbits($n)
{

    // get msb here
    $n = getmsb($n);

    // generate even bits
    // like 101010..
    $n |= $n >> 2;
    $n |= $n >> 4;
    $n |= $n >> 8;
    $n |= $n >> 16;

    // if bits is odd then
    // shift by 1
    if ($n & 1)
        $n = $n >> 1;

    // return even set
    // bits number
    return $n;
}

// set all even bits here
function setallevenbits($n)
{
    // take or with even
    // set bits number
    return $n | getevenbits($n);
}

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

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

// Efficient Javascript program to
// set all even bits of a number

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

    // Return msb
    // increment n by 1
    // and shift by 1
    return (n + 1) >> 1;
}

// Return even set number
function getevenbits(n)
{
    
    // Get msb here
    n = getmsb(n);

    // Generate even
    // bits like 101010..
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;

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

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

// Set all even bits here
function setallevenbits(n)
{
    
    // Take or with even
    // set bits number
    return n | getevenbits(n);
}

// Driver code
let n = 10;

document.write(setallevenbits(n));

// This code is contributed by decode2207  

</script>

Output
10

Method 3: Using bit mask
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 ...1010 is equal to 21 + 23 + 25 + .... 2 (n - !(n % 1)) .

Approach:

  1. Calculate the number of bits using log2(number)
  2. Calculate the largest power m, of the GP series using the formula  (numOfBits - !(numOfBits % 1)).
  3. Calculate the value of the mask using the formula:  a × (r m + 1 - 1) / (r - 1).
  4. Perform the setting operation using number | mask.
C++ 
// Simple CPP program to set all even
// bits of a number
#include <bits/stdc++.h>
using namespace std;

//function to set all the even bits
long long int setEvenBits(long long int n) {
    //calculating number of bits using log
    int numOfBits = 1 + (int)log2(n);
      //if there is only one bit, 
      if (numOfBits == 1)
          return n;
          
    //calculating the max power of GP series
    int m = (numOfBits - !(numOfBits % 1)) / 2 ;
    
    //calculating mask using GP sum
      //which is a(r ^ n - 1) / (r - 1)
      //where a = 2, r = 4, n = m
      
    int mask = (2 * ((1 << (2 * m)) - 1)) / 3;
    
    //toggling all even bits using mask | n
    return mask | n;
    }

//Driver Code
int main()
{
    int n = 102121;
    cout << setEvenBits(n);
    return 0;
}

//This approach is contributed by phasing17
Java 
// Simple Java program to set all even
// bits of a number
import java.util.*;

class GFG {

  // function to set all the even bits
  static int setEvenBits(int n)
  {

    // calculating number of bits using log
    int numOfBits
      = 1 + (int)(Math.log(n) / Math.log(2));
    
    // if there is only one bit,
    if (numOfBits == 1)
      return n;

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

    // calculating mask using GP sum
    // which is a(r ^ n - 1) / (r - 1)
    // where a = 2, r = 4, n = m

    int mask = (2 * ((1 << (2 * m)) - 1)) / 3;

    // toggling all even bits using mask | n
    return mask | n;
  }

  // Driver Code
  public static void main(String[] args)
  {
    int n = 102121;
    System.out.println(setEvenBits(n));
  }
}

// This code is contributed by phasing17
Python3 
# Simple Python3 program to set all even
# bits of a number
from math import log

# function to set all the even bits
def setEvenBits(n):

    # calculating number of bits using log
    numOfBits = 1 + int(log(n, 2))

    # if there is only one bit,
    if numOfBits == 1:
        return n

    # calculating the max power of GP series
    m = int((numOfBits - 1 ^ (numOfBits % 1)) / 2)

    # calculating mask using GP sum
    # which is a(r ^ n - 1) / (r - 1)
    # where a = 2, r = 4, n = m
    mask = int((2 * ((1 << (2 * m)) - 1)) / 3)

    # toggling all even bits using mask | n
    return mask | n

# Driver Code
n = 102121
print(setEvenBits(n))

# This code is contributed by phasing17
C# 
// Simple C# program to set all even
// bits of a number
using System;

class GFG 
{

  // function to set all the even bits
  static int setEvenBits(int n)
  {

    // calculating number of bits using log
    int numOfBits
      = 1 + (int)(Math.Log(n) / Math.Log(2));
    // if there is only one bit,
    if (numOfBits == 1)
      return n;

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

    // calculating mask using GP sum
    // which is a(r ^ n - 1) / (r - 1)
    // where a = 2, r = 4, n = m

    int mask = (2 * ((1 << (2 * m)) - 1)) / 3;

    // toggling all even bits using mask | n
    return mask | n;
  }

  // Driver Code
  public static void Main(string[] args)
  {
    int n = 102121;
    Console.WriteLine(setEvenBits(n));
  }
}

// This code is contributed by phasing17
JavaScript 
// Simple JavaScript program to set all even
// bits of a number

// function to set all the even bits
function setEvenBits(n) {
    
    // calculating number of bits using log
    let numOfBits = 1 + Math.floor(Math.log2(n));
    
      // if there is only one bit, 
      if (numOfBits == 1)
          return n;
          
    // calculating the max power of GP series
    let m = Math.floor((numOfBits - !(numOfBits % 1)) / 2);
    
    // calculating mask using GP sum
      // which is a(r ^ n - 1) / (r - 1)
      // where a = 2, r = 4, n = m
    let mask = Math.floor((2 * ((1 << (2 * m)) - 1)) / 3);
    
    // toggling all even bits using mask | n
    return mask | n;
    }

// Driver Code
let n = 102121;
console.log(setEvenBits(n));

// This approach is contributed by phasing17

Output
110315

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


Next Article
Set all even 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