# Flipping bits

### Problem Statement :

```You will be given a list of 32 bit unsigned integers. Flip all the bits ( 1 -> 0 and 0 -> 1 ) and return the result as an unsigned integer.

Function Description

Complete the flippingBits function in the editor below.

flippingBits has the following parameter(s):

int n: an integer
Returns

int: the unsigned decimal integer result
Input Format

The first line of the input contains q, the number of queries.
Each of the next  q lines contain an integer, n, to process.

Constraints

1  <=   q   <=  100
1   <=   n  <=  2^32

Sample Input 0

3
2147483647
1
0

Sample Output 0

2147483648
4294967294
4294967295```

### Solution :

```                            ```Solution in C :

In   C :

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>

int main() {

int t;
unsigned int n;
scanf("%d", &t);
while(t-- > 0) {
scanf("%u", &n);
printf("%u\n", ~n);
}
return 0;
}```
```

```                        ```Solution in C++ :

In    C++ :

#include <cstdio>
using namespace std;

int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i ++) {
unsigned int val;
scanf("%u", &val);
printf("%u\n", ~val);
}
return 0;
}```
```

```                        ```Solution in Java :

In   Java  :

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();

for(int i = 0; i < n; i++) {
long l = sc.nextLong();
}
}
}```
```

```                        ```Solution in Python :

In   Python3  :

T = int(input())
for _ in range(T) :
N = int(input())
print(0xffffffff & ~N)```
```

## Tree Coordinates

We consider metric space to be a pair, , where is a set and such that the following conditions hold: where is the distance between points and . Let's define the product of two metric spaces, , to be such that: , where , . So, it follows logically that is also a metric space. We then define squared metric space, , to be the product of a metric space multiplied with itself: . For

## Array Pairs

Consider an array of n integers, A = [ a1, a2, . . . . an] . Find and print the total number of (i , j) pairs such that ai * aj <= max(ai, ai+1, . . . aj) where i < j. Input Format The first line contains an integer, n , denoting the number of elements in the array. The second line consists of n space-separated integers describing the respective values of a1, a2 , . . . an .

## Self Balancing Tree

An AVL tree (Georgy Adelson-Velsky and Landis' tree, named after the inventors) is a self-balancing binary search tree. In an AVL tree, the heights of the two child subtrees of any node differ by at most one; if at any time they differ by more than one, rebalancing is done to restore this property. We define balance factor for each node as : balanceFactor = height(left subtree) - height(righ

## Array and simple queries

Given two numbers N and M. N indicates the number of elements in the array A[](1-indexed) and M indicates number of queries. You need to perform two types of queries on the array A[] . You are given queries. Queries can be of two types, type 1 and type 2. Type 1 queries are represented as 1 i j : Modify the given array by removing elements from i to j and adding them to the front. Ty