> ## Content Index
> Fetch the complete content index at: https://www.javahandbook.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Bitwise OR, Computations, and Examples
- URL: https://www.javahandbook.com/bitmask/bitwise-or-computations-and-examples/
- Published: 2024-06-16T07:27:50.000Z
- Updated: 2024-06-17T03:39:41.000Z
- Author: Gopi Gorantala
- Tags: OR Operator, #bitmask, #docs

Here, we will discuss the '|' operator in detail.

### Introduction

A Bitwise **OR** is a binary operator that takes two-bit patterns of equal length and performs the logical inclusive OR operation on each corresponding bits pair. The result in each position is 0 if both bits are 0\. Otherwise, the result is 1.

### Bitwise OR

The Bitwise **OR** operator does the following:

- It is a binary operator that takes two numbers.
- When we do Bitwise `|` of those two numbers, it considers the binary representation of these two numbers.
- The Bitwise OR operator compares bit by bit in binary representation, and whatever binary representation you get, the corresponding integer is returned as an output.

The integer data type takes `4` bytes in C, C++, and Java programming languages.

```java
4 Bytes = 4 * (8 bits) = 32 bits. {1 Byte = 8 bits}
```

Let’s see one of the above examples in binary representation.

### Example

For simplicity, let’s represent these in 16-bit instead of 32-bit binary. We are going one step at a time. In each of these illustrations, we see the right-most significant bit is calculated.

### Illustration

```json
a = 12
b = 10
---------------------------------
a in Binary : 0000 0000 0000 1100
b in Binary : 0000 0000 0000 1010
---------------------------------
a | b       :                   0
---------------------------------

```

```json
a = 12
b = 10
---------------------------------
a in Binary : 0000 0000 0000 1100
b in Binary : 0000 0000 0000 1010
---------------------------------
a | b       :                  10
---------------------------------
```

```json
a = 12
b = 10
---------------------------------
a in Binary : 0000 0000 0000 1100
b in Binary : 0000 0000 0000 1010
---------------------------------
a | b       :                 110
---------------------------------
```

```json
a = 12
b = 10
---------------------------------
a in Binary : 0000 0000 0000 1100
b in Binary : 0000 0000 0000 1010
---------------------------------
a | b       :                1110
---------------------------------
```

```json
a = 12
b = 10
---------------------------------
a in Binary : 0000 0000 0000 1100
b in Binary : 0000 0000 0000 1010
---------------------------------
a | b       : 0000 0000 0000 1110
---------------------------------
```

The `|` operation starts from the rightmost bit traversing towards the leftmost bit in the 32-bit binary representation, as represented above.

Below is the code representation of the `|` operator.

### Code

### Java

```java
class OROperation {
    private static int helper(int x, int y) {
        return x | y;
    }

    public static void main(String[] args) {
        int x = 12;
        int y = 10;
        System.out.println("Bitwise OR of " + x + ", " + y + " is: " + helper(x, y)); // yields to 14
    }
}

// Output : Bitwise OR of 12, 10 is: 14
```

### Python

```py
def OrOperation(x,y):
    return x|y

x=12
y=10
print("Bitwise OR of ",x ,",",y,"is : ",OrOperation(x,y))
```

### JavaScript

```javascript
const OrOperation = (x, y) => x | y;

const x = 12;
const y = 10;

console.log (`Bitwise OR of ${x}, ${y} is = ${OrOperation (x, y)}`);

// Output : Bitwise OR of 12, 10 is = 14
```

### C++

```cpp
#include <iostream>

using namespace std;

int helper(int x, int y){
  return x | y;
}

int main(){
  int x = 12, y = 10;
  cout << "Bitwise OR of " << x << " , " << y << " is " << helper(x, y);
  return 0;
  
// Output : Bitwise OR of 12, 10 is = 14  
```

### TypeScript

```typescript
export const OrOperation = (x: number, y: number): number => x | y;

const x: number = 12;
const y: number = 10;

console.log(`Bitwise OR of ${x}, ${y} is = ${OrOperation(x, y)}`);

// Output : Bitwise OR of 12, 10 is = 14  
```

The following lesson will apply the Bitwise approach to solve a few problems.

Let’s jump into our first problem using the Bitwise `|` operator.