# Bitwise Operations in Kotlin Hindi

### Bitwise Operations in Kotlin Hindi

Unlike Java, there are no bitwise and bitshift operators in Kotlin. To perform these task, various functions (supporting infix notation) are used:

• `shl` – Signed shift left
• `shr` – Signed shift right
• `ushr` – Unsigned shift right
• `and` – Bitwise and
• `or` – Bitwise or
• `xor` – Bitwise xor
• `inv` – Bitwise inversion

## 1. or

The `or` function compares corresponding bits of two values. If either of the bits is 1, it gives 1. If not, it gives 0. For example,

```12 = 00001100 (In Binary)
25 = 00011001 (In Binary)

Bitwise OR Operation of 12 and 25
00001100 or
00011001
________
00011101  = 29 (In decimal)```

### Example: Bitwise or Operation

``````fun main(args: Array<String>) {

val number1 = 12
val number2 = 25
val result: Int

result = number1 or number2   // result = number1.or(number2)
println(result)
}``````

When you run the program, the output will be:

`29`

## 2. and

The `and` function compares corresponding bits of two values. If both bits are 1, it is evaluated to 1. If either of the bits is 0, it is evaluated to 0. For example,

```12 = 00001100 (In Binary)
25 = 00011001 (In Binary)

Bit Operation of 12 and 25
00001100 and
00011001
________
00001000  = 8 (In decimal)```

### Example: Bitwise and Operation

``````fun main(args: Array<String>) {

val number1 = 12
val number2 = 25
val result: Int

result = number1 and number2   // result = number1.and(number2)
println(result)
}``````

When you run the program, the output will be:

`8`

## 3. xor

The `xor` function compares corresponding bits of two values. If corresponding bits are different, it gives 1. If corresponding bits are same, it gives 0. For example,

```12 = 00001100 (In Binary)
25 = 00011001 (In Binary)

Bitwise OR Operation of 12 and 25
00001100 xor
00011001
________
00010101  = 21 (In decimal)```

### Example: Bitwise xor Operation

``````fun main(args: Array<String>) {

val number1 = 12
val number2 = 25
val result: Int

result = number1 xor number2   // result = number1.xor(number2)
println(result)
}``````

When you run the program, the output will be:

`21`

## 4. inv()

The inv() function inverts the bit pattern. It makes every 0 to 1, and every 1 to 0.

```35 = 00100011 (In Binary)

Bitwise complement Operation of 35
00100011
________
11011100  = 220 (In decimal)```

### Example: Bitwise complement

``````fun main(args: Array<String>) {

val number = 35
val result: Int

result = number.inv()
println(result)
}``````

When you run the program, the output will be:

`-36`

Why are we getting output -36 instead of 220?

It’s because the compiler is showing 2’s complement of that number; negative notation of the binary number.

For any integer n, 2’s complement of n will be `-(n+1)`.

``` Decimal         Binary                      2's complement
------- –       – ----- –          – ----------------------------------- –
0             00000000          -(11111111+1) = -00000000 = -0(decimal)
1             00000001          -(11111110+1) = -11111111 = -256(decimal)
12            00001100          -(11110011+1) = -11110100 = -244(decimal)
220           11011100          -(00100011+1) = -00100100 = -36(decimal)

Note: Overflow is ignored while computing 2's complement.```

The bitwise complement of 35 is 220 (in decimal). The 2’s complement of 220 is -36. Hence, the output is -36 instead of 220.

## 5. shl

The `shl` function shifts bit pattern to the left by certain number of specified bits, and zero bits are shifted into the low-order positions.

```212 (In binary: 11010100)

212 shl 1 evaluates to 424 (In binary: 110101000)
212 shl 0 evaluates to 212 (In binary: 11010100)
212 shl 4 evaluates to 3392 (In binary: 110101000000)```

### Example: Bitwise left shift

``````fun main(args: Array<String>) {
val number = 212

println(number shl 1)
println(number shl 0)
println(number shl 4)
}``````

When you run the program, the output will be:

```424
212
3392```

## 6. shr

The `shr` function shifts bit pattery to the right by certin number of specified bits.

```212 (In binary: 11010100)

212 shr 1 evaluates to 106 (In binary: 01101010)
212 shr 0 evaluates to 212 (In binary: 11010100)
212 shr 8 evaluates to 0 (In binary: 00000000)```

If the number is a 2’s complement signed number, the sign bit is shifted into the high-order positions.

``````fun main(args: Array<String>) {
val number = 212

println(number shr 1)
println(number shr 0)
println(number shr 8)
}``````

When you run the program, the ouput will be:

```106
212
0```

## 7. ushr

The `ushr` function shifts zero into the leftmost position.

### Example: signed and unsigned Right Shift

``````fun main(args: Array<String>) {
val number1 = 5
val number2 = -5

// Signed right shift
println(number1 shr 1)

// Unsigned right shift
println(number1 ushr 1)

// Signed right shift
println(number2 shr 1)

// Unsigned right shift
println(number2 ushr 1)
}``````

When you run the program, the output will be:

```2
2
-3
2147483645```

Notice, how signed and unsigned right shift function works differently for 2’s complement.

The 2’s complement of `2147483645` is `3`.