Bitwise OR( | ) of all even number from 1 to N

Namachila 4 minutes ago

0 0 5 minutes read

Given a number N, the task is to find the bitwise OR( | ) of all even numbers from 1 to N.

Examples:

Input: 2
Output: 2

Input: 10
Output: 14
Explanation: 2 | 4 | 6 | 8 | 10 = 14

Naive Approach:

Initialize the result as 2.
Iterate the loop from 4 to n (for all even number) and update result by finding bitwise or ( | ).

Below is the implementation of the approach:

C++

// C++ implementation of the above approach
#include <iostream>
using namespace std;
 
// Function to return the bitwise OR
// of all the even numbers upto N
int bitwiseOrTillN(int n)
{
    // Initialize result as 2
    int result = 2;
 
    for (int i = 4; i <= n; i = i + 2) {
        result = result | i;
    }
    return result;
}
 
// Driver code
int main()
{
    int n = 10;
    cout << bitwiseOrTillN(n);
    return 0;
}

Java

// Java implementation of the above approach 
class GFG
{
     
    // Function to return the bitwise OR 
    // of all the even numbers upto N 
    static int bitwiseOrTillN(int n) 
    { 
        // Initialize result as 2 
        int result = 2; 
     
        for (int i = 4; i <= n; i = i + 2)
        { 
            result = result | i; 
        } 
        return result; 
    } 
     
    // Driver code 
    static public void main (String args[])
    { 
        int n = 10; 
        System.out.println(bitwiseOrTillN(n)); 
    } 
}
 
// This code is contributed by AnkitRai01

Python3

# Python 3 implementation of the above approach
 
# Function to return the bitwise OR
# of all the even numbers upto N
def bitwiseOrTillN ( n ):
     
    # Initialize result as 2
    result = 2;
 
    for i in range(4, n + 1, 2) :
        result = result | i
     
    return result
 
# Driver code
n = 10;
print(bitwiseOrTillN(n));
 
# This code is contributed by ANKITKUMAR34

C#

// C# implementation of the above approach 
using System;
 
class GFG
{
     
    // Function to return the bitwise OR 
    // of all the even numbers upto N 
    static int bitwiseOrTillN(int n) 
    { 
        // Initialize result as 2 
        int result = 2; 
     
        for (int i = 4; i <= n; i = i + 2)
        { 
            result = result | i; 
        } 
        return result; 
    } 
     
    // Driver code 
    static public void Main ()
    { 
        int n = 10; 
        Console.WriteLine(bitwiseOrTillN(n)); 
    } 
}
 
// This code is contributed by AnkitRai01

Javascript

<script>
 
// Javascript implementation of the above approach
 
// Function to return the bitwise OR
// of all the even numbers upto N
function bitwiseOrTillN(n)
{
     
    // Initialize result as 2
    var result = 2;
 
    for(var i = 4; i <= n; i = i + 2)
    {
        result = result | i;
    }
    return result;
}
 
// Driver code
var n = 10;
document.write( bitwiseOrTillN(n));
 
// This code is contributed by noob2000
 
</script>

Output:

Time Complexity: O(n), where n is the given integer.
Auxiliary Space: O(1), no extra space is required, so it is a constant.

Efficient Approach: Compute the total number of bits in N. In bitwise OR, the rightmost bit will be 0 and all other bits will be 1. Therefore, return pow(2, total no. of bits)-2. It will give the equivalent value in decimal of bitwise OR.

Below is the implementation of the approach:

C++

// C++ implementation of the above approach
#include <iostream>
#include <math.h>
using namespace std;
 
// Function to return the bitwise OR
// of all even numbers upto N
int bitwiseOrTillN(int n)
{
    // For value less than 2
    if (n < 2)
        return 0;
 
    // Count total number of bits in bitwise or
    // all bits will be set except last bit
    int bitCount = log2(n) + 1;
 
    // Compute 2 to the power bitCount and subtract 2
    return pow(2, bitCount) - 2;
}
 
// Driver code
int main()
{
    int n = 10;
    cout << bitwiseOrTillN(n);
    return 0;
}

Java

// Java implementation of the above approach 
class GFG 
{
     
    // Function to return the bitwise OR 
    // of all even numbers upto N 
    static int bitwiseOrTillN(int n) 
    { 
        // For value less than 2 
        if (n < 2) 
            return 0; 
     
        // Count total number of bits in bitwise or 
        // all bits will be set except last bit 
        int bitCount = (int)(Math.log(n)/Math.log(2)) + 1; 
     
        // Compute 2 to the power bitCount and subtract 2 
        return (int)Math.pow(2, bitCount) - 2; 
    } 
     
    // Driver code 
    public static void main (String[] args)
    { 
        int n = 10; 
        System.out.println(bitwiseOrTillN(n)); 
    } 
}
 
// This code is contributed by AnkitRai01

Python3

# Python3 implementation of the above approach 
from math import log2
 
# Function to return the bitwise OR 
# of all even numbers upto N 
def bitwiseOrTillN(n) : 
 
    # For value less than 2 
    if (n < 2) :
        return 0; 
 
    # Count total number of bits in bitwise or 
    # all bits will be set except last bit 
    bitCount = int(log2(n)) + 1; 
 
    # Compute 2 to the power bitCount and subtract 2 
    return pow(2, bitCount) - 2; 
 
# Driver code 
if __name__ == "__main__" : 
 
    n = 10; 
    print(bitwiseOrTillN(n)); 
 
# This code is contributed by AnkitRai01

C#

// C# implementation of the above approach 
using System;
 
class GFG 
{
     
    // Function to return the bitwise OR 
    // of all even numbers upto N 
    static int bitwiseOrTillN(int n) 
    { 
        // For value less than 2 
        if (n < 2) 
            return 0; 
     
        // Count total number of bits in bitwise or 
        // all bits will be set except last bit 
        int bitCount = (int)(Math.Log(n)/Math.Log(2)) + 1; 
     
        // Compute 2 to the power bitCount and subtract 2 
        return (int)Math.Pow(2, bitCount) - 2; 
    } 
     
    // Driver code 
    public static void Main()
    { 
        int n = 10; 
        Console.WriteLine(bitwiseOrTillN(n)); 
    } 
}
 
// This code is contributed by AnkitRai01

Javascript

<script>
// Javascript implementation of the approach
 
// Function to return the bitwise OR
// of all even numbers upto N
function bitwiseOrTillN(n)
{
    // For value less than 2
    if (n < 2)
        return 0;
 
    // Count total number of bits in bitwise or
    // all bits will be set except last bit
    var bitCount = parseInt(Math.log2(n) + 1);
 
    // Compute 2 to the power bitCount and subtract 2
    return Math.pow(2, bitCount) - 2;
}
 
 
// Driver code
var n = 10;
document.write(  bitwiseOrTillN(n));
 
//This code is contributed by SoumikMondal
</script>

Output:

Time Complexity: O(log(log n), where n is the given integer.
Auxiliary Space: O(1), no extra space is required, so it is a constant.

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 zambiatek!