Using the associative and commumtative property of XOR, we will calculate the XOR of the array, which is mathematically equal to 0 ^ (distinct element) = distinct element, found it.
// arr - input array
// size - size of array

int FindUnique(int arr[], int size)
{
    int ret = 0;
    for(int i=0; i<size;i++)
        ret ^= arr[i];
    return ret;
}

// arr - input array
// size - size of array

int MissingNumber(int arr[], int size)
{
    int idealSum = (size-2)*(size-1)/2; // sum from 0 to n-2, i.e 1 is missing
    int realSum = 0;
    for(int i=0; i<size; i++)
        realSum+=arr[i];
    return realSum-idealSum;
}

// input1 - first array
// input2 - second array
// size1 - size of first array
// size2 - size of second array
void intersection(int input1[], int input2[], int size1, int size2)
{
    std::sort(input1, input1+size1);
    std::sort(input2, input2+size2);
    int i = 0, j = 0;

    while(i < size1 && j < size2)
    {
        if(input1[i]==input2[j])
        {
            cout << input1[i] <<  endl;
            i++, j++;
        }
        else if(input1[i]<input2[j]) // you won't be able to find input2[j] except for the next elements of input1[i]
            i++;
        else if(input1[i]>input2[j]) // you won't be able to find input1[i] except for the next elements of input2[j]
            j++;
    }
    // that was easy enough
    // we can use maps too, time complexity is O(n)
}

#include<algorithm>
void pairSum(int input[], int size, int x)
{
    *// start from the two ends*
    // Advantage: As compare the biggest to the smallest, if they sum equals
    // the numbers at hand, then print em. Else leave them

    // We need to scan further as we might get the sum in the insides.

    // when we scan if ar[i]+arr[j]<su, move from the front. The left part(at hand) is useless
    // if(ar[i]+ar[j]>sum), right part(check with while) is useless.
    // when we get (ar[i]==arr[j])
    // case1: if(ar[i]==arr[j])
            // print the number len1*(len1-1)/2
    // case 2:
    // count the stretch for both the ends and print the numbers len1*len2 times.

    // T.C = nlong + n  = O(nlogn), SC = O(1)

    sort(input, input+size);
    int i = 0, j = size - 1;
    int len1 = 0, len2 = 0;
    while(i<j) // i==j is useless
    {

        if(input[i]==input[j]) // if both are equal then everything between them is the same
        {
            if(input[i]+input[j]!=x)
                break;
            else  // redundant
            {
                len1 = j-i+1;
                for(int k=0; k < (len1*(len1-1))/2; k++)
                    cout << input[i] << " " << input[i] << endl;
                break;
            }
        } // saves a lot of time, you can check the case using custom input

        else // input[i] is not equal to input[j]
        {
            if(input[i]+input[j]<x)
            {
                while(i<j && input[i]+input[j]<x)
                    i++; // will stop is sum>=x the next case will take care of it.
            }
            else if(input[i]+input[j]>x)
            {
                while(i<j && input[i]+input[j]>x)
                    j--; // will stop is sum>=x the next case will take care of it.
            }
            else
            {
                len1 = 1, len2 = 1;
                while(input[i]==input[++i]) // not equal so for sure will find a wall or interface
                    len1+=1; // don't worry about i and j as input[i] and input[j] cannot be the same for all values
                while(input[j]==input[--j]) // not equal so for sure will find a wall or interface
                    len2+=1;
                for(int k=0; k < len1*len2; k++)
                    cout << input[i-1] << " " << input[j+1] << endl;
            }
        }
    }
}

// arr - input array
// size - size of array
// x - sum of triplets

void FindTriplet(int arr[], int size, int x)
{
    /* Don't write main().
     * Don't read input, it is passed as function argument.
     * Print output and don't return it.
     * Taking input is handled automatically.
     */

}

// arr - input array
// n - size of array
// d - array to be rotated by d elements

#include<algorithm>
void rotate(int *arr, int d, int n)
{
    if(d==0)
        return;
	d%=n;
    d = n-d;
    int buckets = __gcd(n, d);
    int bucket_size = n/buckets;
    int position = 0;
    int store = arr[0], swap;
    for(int i=0; i<buckets; i++)
    {
        for(int j=0; j<bucket_size; j++)
        {
            position = (position+d)%n;
            swap = arr[position];
            arr[position] = store;
            store = swap;
        }
        store=arr[++position]; // new bucket
    }
}

// arr - input array
// n - size of array

int FindSortedArrayRotation(int arr[], int n)
{
    /* Don't write main().
     * Don't read input, it is passed as function argument.
     * Return output and don't print it.
     * Taking input and printing output is handled automatically.
     */

}